Techlist.io - Korean Tech Blog Curator

figmaAug 11, 20252 min readCurated summary

8 Tips for Designers Building Branded Templates in Figma Buzz | Figma Blog

Figma Buzz templates should be designed as flexible systems, not just finished compositions. The post argues that brand designers need to anticipate marketers’ editing needs by building in guardrails for content, spacing, scaling, and branding. Thoughtful template structure helps teams create accurate, on-brand assets at scale without requiring constant designer review. ## Design in Figma Design First - Begin by creating the asset in a Figma Design frame, where designers can use components and Figma Draw’s vector tools. - Once the design is ready, copy it into Figma Buzz for final adjustments and publication as a template. - This workflow combines expressive design capabilities with Buzz’s collaborative marketing features. ## Use Auto Layout for Flexible Templates - Auto layout keeps elements aligned and maintains consistent spacing as content changes. - It is especially useful for buttons, text boxes, and image containers. - Longer headlines or other variable content can expand without pushing surrounding elements out of alignment. - Auto layout provides the responsive foundation needed for templates used across different assets and formats. ## Separate Text Layers by Input - Create a separate text layer for every unique piece of content, particularly when inputs use different fonts, sizes, or styles. - Modular text layers are essential for Bulk create, which maps CSV or XLSX fields to individual design layers. - Combining multiple inputs or styles in one layer can cause formatting problems and make bulk updates difficult. - Separating layers keeps formatting consistent across campaigns and generated assets. ## Lock Image and Vector Aspect Ratios - Lock the aspect ratio of images and vector graphics using the square icon beside the width and height controls. - Templates often need to be adapted from one format—such as a 1080 × 1080 social post—to others, including Instagram Stories or web banners. - Aspect-ratio locking prevents logos, portraits, illustrations, and other graphics from becoming stretched or compressed. - This setting acts as a simple safeguard against accidental distortion during editing. ## Name Layers Clearly - Rename layers so teammates can understand what each editable field controls in Buzz’s Edit Content panel. - Text layers are initially named after their visible canvas text; use Command + R or edit the layer name directly to replace it. - Figma AI can help rename large numbers of layers. - Clear labels make template editing more intuitive, much like completing a form, especially when many layers are available for customization.

Read original

Responsive Design Auto Layout Figma Design Figma Ai+3

lineAug 8, 2025Original article

Sharing the workflow of a 3rd (opens in new tab)

This blog post outlines a structured nine-step workflow designed to enhance development efficiency and improve the code review experience within a collaborative team environment. By emphasizing pre-implementation simulation, task visualization through Jira, and proactive self-feedback, the author demonstrates how breaking work into manageable, reviewer-friendly units leads to more predictable and reliable software delivery. The core conclusion is that prioritizing "reviewability" through small, logical increments fosters team trust and reduces technical debt. ### Strategic Planning and Simulation * Begin by thoroughly reviewing requirements and simulating the feature’s behavior, focusing specifically on data flow, state management, and edge cases. * Proactively communicate with stakeholders to clarify ambiguities and suggest user experience improvements before any code is written. * Draft high-level diagrams or flowcharts to map out how data points interact and where specific logic should reside, ensuring a solid architectural foundation. ### Task Visualization and Collaborative Alignment * Organize features into Jira Epics and decompose them into granular tickets that include estimated effort and dependencies. * Sync with teammates early—specifically between workflow design and ticket creation—to align on technical direction and prevent significant rework during the final review stage. * Ensure ticket titles are concise and descriptive to allow teammates to understand the project's progress at a glance. ### PoC-Driven Iteration and Self-Feedback * Conduct Proof of Concept (PoC) or prototyping to validate assumptions and identify unforeseen technical challenges before committing to a final implementation. * Perform self-feedback by checking the volume of code changes; the author suggests a 400-line threshold, beyond which a ticket should be split into sub-tasks to maintain clarity. * Use tools like `git diff` or temporary PR branches to review your own work from the perspective of a reviewer, identifying parts of the code that may be difficult to digest. ### Implementation and Documentation for Reviewers * Commit code in small, meaningful increments with clear messages, following a logical sequence such as defining interfaces before their actual implementations. * Draft Pull Requests (PRs) using standardized templates that include the purpose of the change, affected features, and developer test results. * Include visual aids, such as videos or screenshots, for complex UI changes or intricate workflows to reduce the cognitive load on the reviewer. ### Future Process Refinement * Improve the accuracy of project timelines by strictly recording actual time spent on tickets compared to original estimates in Jira. * Analyze the delta between "Estimated" and "Actual" time to better understand personal development velocity and refine future scheduling. Adopting this systematic approach helps developers transition from simply "writing code" to managing a complete technical lifecycle. For teams prioritizing code quality, implementing a line-count threshold for PRs and scheduling early-stage technical alignment sessions can significantly reduce "review fatigue" and streamline the path to production.

Github Code Review Git Jira+4

lineAug 7, 2025Original article

Flexible Multi-site Architecture Designed with N (opens in new tab)

LINE NEXT optimized its web server infrastructure by transitioning from fragmented, manual Nginx setups to a centralized native Nginx multi-site architecture. By integrating global configurations and automating the deployment pipeline with Ansible, the team successfully reduced service launch lead times by over 80% while regaining the ability to use advanced features like GeoIP and real client IP tracking. This evolution ensures that the infrastructure can scale to support over 100 subdomains across diverse global services with high reliability and minimal manual overhead. ## Evolution of Nginx Infrastructure * **PMC-based Structure**: The initial phase relied on a Project Management Console using `rsync` via SSH; this created security risks and led to fragmented, siloed configurations that were difficult to maintain. * **Ingress Nginx Structure**: To improve speed, the team moved to Kubernetes-based Ingress using Helm charts, which automated domain and certificate settings but limited the use of native Nginx modules and complicated the retrieval of real client IP addresses. * **Native Nginx Multi-site Structure**: The current hybrid approach utilizes native Nginx managed by Ansible, combining the speed of configuration-driven setups with the flexibility to use advanced modules like GeoIP and Loki for log collection. ## Configuration Integration and Multi-site Management * **Master Configuration Extraction**: Common directives such as `timeouts`, `keep-alive` settings, and `log formats` were extracted into a master Nginx configuration file to eliminate redundancy across services. * **Hierarchical Directory Structure**: Inspired by Apache, the team adopted a `sites-available` structure where individual `server` blocks for different services (alpha, beta, production) are managed in separate files. * **Operational Efficiency**: This integrated structure allows a single Nginx instance to serve multiple sites simultaneously, significantly reducing the time required to add and deploy new service domains. ## Automated Deployment with Ansible * **Standardized Workflow**: The team replaced manual processes with Ansible playbooks that handle everything from cloning the latest configuration from Git to extracting environment-specific files. * **Safety and Validation**: The automated pipeline includes mandatory Nginx syntax verification (`nginx -t`) and process status checks to ensure stability before a deployment is finalized. * **Rolling Deployments**: To minimize service impact, updates are pushed sequentially across servers; the process automatically halts if an error is detected at any stage of the rollout. To effectively manage a rapidly expanding portfolio of global services, infrastructure teams should move toward a "configuration-as-code" model that separates common master settings from service-specific logic. Leveraging automation tools like Ansible alongside a native Nginx multi-site structure provides the necessary balance between rapid deployment and the granular control required for complex logging and security requirements.

Kubernetes Nginx Ansible Infrastructure Automation+4

lineAug 7, 2025Original article

Hey, won't you become a (opens in new tab)

Hack Day 2025 serves as a cornerstone of LY Corporation’s engineering culture, bringing together diverse global teams to innovate beyond their daily operational scopes. By fostering a high-intensity environment focused on creative freedom, the event facilitates technical growth and strengthens interpersonal bonds across international branches. This 19th edition demonstrated how rapid prototyping and cross-functional collaboration can transform abstract ideas into functional AI-driven prototypes within a strict 24-hour window. ### Structure and Participation Dynamics * The hackathon follows a "9 to 9" format, providing exactly 24 hours of development time followed by a day for presentations and awards. * Participation is inclusive of all roles, including developers, designers, planners, and HR staff, allowing for holistic product development. * Teams can be "General Teams" from the same legal entity or "Global Mixed Teams" comprising members from different regions like Korea, Japan, Taiwan, and Vietnam. * The Developer Relations (DevRel) team facilitates team building for remote employees using digital collaboration tools like Zoom and Miro. ### AI-Powered Personality Analysis Project * The author's team developed a "Scouter" program inspired by Dragon Ball, designed to measure professional "combat power" based on communication history. * The system utilizes Slack bots and AI models to analyze message logs and map them to the Big 5 Personality traits (Openness, Conscientiousness, Extraversion, Agreeableness, and Neuroticism). * Professional metrics are visualized as game-like character statistics to make personality insights engaging and less intimidating. * While the original plan involved using AI to generate and print physical character cards, hardware failures with photo printers forced a technical pivot to digital file downloads. ### High-Pressure Presentation and Networking * Every team is allotted a strict 90-second window to pitch their product and demonstrate a live demo. * The "90-second rule" includes a mandatory microphone cutoff to maintain momentum and keep the large-scale event engaging for all attendees. * Dedicated booth sessions follow the presentations, allowing participants to provide hands-on experiences to colleagues and judges. * The event emphasizes "Perfect the Details," a core company value, by encouraging teams to utilize all available resources—from whiteboards to AI image generators—within the time limit. ### Environmental Support and Culture * The event occupies an entire office floor, providing a high-density yet comfortable environment designed to minimize distractions during the "Hack Time." * Cultural exchange is encouraged through "humanity snacks," where participants from different global offices share local treats in dedicated rest areas. * Strategic scheduling, such as "Travel Days" for international participants, ensures that teams can focus entirely on technical execution once the event begins. Participating in internal hackathons provides a vital platform for testing new technologies—like LLMs and personality modeling—that may not fit into immediate product roadmaps. For organizations with hybrid work models, these intensive in-person events are highly recommended to bridge the communication gap and build lasting trust between global teammates.

AI Generative AI Prompt Engineering Redis+5

googleAug 6, 2025Original article

Achieving 10,000x training data reduction with high-fidelity labels (opens in new tab)

Google Ads researchers have developed a scalable active learning curation process that reduces the volume of training data required for fine-tuning LLMs by up to four orders of magnitude. By iteratively identifying the most informative and diverse examples through clustering and expert review, the method achieves significantly higher human-model alignment than traditional large-scale crowdsourced datasets. This approach effectively addresses the high costs and complexities of classifying ambiguous content, such as unsafe ads, where high-fidelity data is scarce and concept drift is frequent. ### The Iterative Curation Process * **Initial Labeling:** The process begins with a zero- or few-shot model (LLM-0) that generates a large, typically imbalanced dataset of "positive" and "benign" labels. * **Clustering and Confusion Identification:** Separate clusters are created for each label set; overlapping clusters indicate areas where the model is confused. * **Expert Sampling:** Human experts review pairs of examples located near the decision boundary of these overlapping clusters, prioritizing those that cover a larger area of the search space to ensure diversity. * **Recursive Refinement:** Expert labels are split into fine-tuning and evaluation sets; the model is retrained and the process repeats until model-human alignment plateaus or matches internal expert agreement. ### Measuring Alignment via Cohen’s Kappa * **Metric Selection:** Because ad safety is often subjective, the researchers use Cohen’s Kappa instead of precision and recall to measure how well two independent annotators align beyond chance. * **Performance Benchmarks:** A Kappa value above 0.8 is considered exceptional, while 0.4 is the minimum for acceptability. * **Goal Alignment:** The curation process aims to move model performance toward the "ceiling" of internal human agreement (which measured between 0.78 and 0.81 in these experiments). ### Experimental Results and Efficiency * **Model Scaling:** Experiments involved fine-tuning Gemini Nano-1 (1.8B parameters) and Nano-2 (3.25B parameters) on tasks of varying complexity. * **Drastic Data Reduction:** The curated method reached performance plateaus using fewer than 500 expert-labeled examples, compared to a baseline of 100,000 crowdsourced labels. * **Quality Gains:** Despite using 10,000x less data, the curated models saw up to a 65% improvement in alignment with human experts over the crowdsourced baselines. * **Class Balancing:** The process naturally corrected for production imbalances, moving from <1% positive examples in raw traffic to ~40% in the final curated sets. This curation method is a highly effective strategy for organizations managing high-stakes classification tasks where "ground truth" is subjective or data curation is prohibitively expensive. By shifting focus from data quantity to the quality and diversity of examples at the decision boundary, developers can maintain high-performing models that adapt quickly to evolving safety policies.

AI Large Language Models Machine Learning Gemini+4

figmaAug 6, 20252 min readCurated summary

Getting into the groove: How music shaped the scatter brushes in Figma Draw | Figma Blog

Figma Draw’s 10 new scatter brushes were inspired by music genres, using rhythm, repetition, and texture as guides for visual experimentation. Product designer Rogie King created 99 designs, which the team narrowed down to brushes named Bubblegum, Witch house, Shoegaze, Honky-tonk, Screamo, Drone, Doo-wop, Spoken word, Vaporwave, and Oi!. The project also emphasizes making digital art feel approachable and expressive for users without formal artistic training. ## Music as a Design Framework - Scatter-brush patterns resemble musical beats because their elements repeat along a stroke. - Brush settings such as gap, wiggle, and jitter parallel musical controls like tempo, texture, and volume. - UX writer Molly Rosen Marriner gathered genre ideas from the Every Noise At Once genre map and Figma employees. - Visually suggestive genres—including Electroclash, Drone, and Witch house—helped guide the brush concepts. ## From Genres to Brush Strokes - Rogie began with familiar uses such as stippling and shading, then explored more expressive interpretations. - He listened to representative songs and researched each genre’s visual culture. - The Screamo brush, for example, drew on early-2000s imagery associated with mosh pits, dark clothing, and heavy eyeliner. - He also consulted others, including his son, to better understand genres such as Shoegaze. ## Selecting the Final Collection - Rogie produced 99 scatter-brush designs through an intentionally exploratory process. - The Figma team voted on designs that offered the most flexibility and expressive potential. - Molly later matched the selected brushes to music genres, sometimes inventing or adjusting associations to fit the visuals. - The final set includes 10 brushes designed for stippling, shading, texture, and playful decoration. ## Making Digital Art More Accessible - The brushes expand the emotional and stylistic range available in Figma Draw, from mysterious wisps to repeated smiley-face splatters. - The genre-based names avoid overly technical art-school terminology. - Rogie wanted users to feel free to experiment without needing formal artistic education or experience with physical media. - The collection presents artistic expression as accessible, playful, and open to everyone.

Read original

Figma Graphic Design Figma Draw Vector Editing+2

googleAug 5, 2025Original article

Insulin resistance prediction from wearables and routine blood biomarkers (opens in new tab)

Researchers at Google have developed a novel machine learning approach to predict insulin resistance (IR) by integrating wearable device data with routine blood biomarkers. This method aims to provide a scalable, less invasive alternative to traditional "gold standard" tests like the euglycemic insulin clamp or specialized HOMA-IR assessments. The study demonstrates that combining digital biomarkers with common laboratory results can effectively identify individuals at risk for type 2 diabetes, particularly within high-risk populations. ## Barriers to Early Diabetes Screening * Insulin resistance is a primary precursor to approximately 70% of type 2 diabetes cases, yet it often remains undetected until the disease has progressed. * Current diagnostic standards are frequently omitted from routine check-ups due to high costs, invasiveness, and the requirement for specific insulin blood tests that are not standard practice. * Early detection is vital because insulin resistance is often reversible through lifestyle modifications, making accessible screening tools a high priority for preventative medicine. ## The WEAR-ME Multimodal Dataset * The research utilized the "WEAR-ME" study, which collected data from 1,165 remote participants across the U.S. via the Google Health Studies app. * Digital biomarkers were gathered from Fitbit and Google Pixel Watch devices, tracking metrics such as resting heart rate, step counts, and sleep patterns. * Clinical data was provided through a partnership with Quest Diagnostics, focusing on routine blood biomarkers like fasting glucose and lipid panels, supplemented by participant surveys on diet, fitness, and demographics. ## Predictive Modeling and Performance * Deep neural network models were trained to estimate HOMA-IR scores by analyzing different combinations of the collected data streams. * While models using only wearables and demographics achieved an area under the receiver operating characteristic curve (auROC) of 0.70, adding fasting glucose data boosted the auROC to 0.78. * The most comprehensive models, which combined wearables, demographics, and full routine blood panels, achieved the highest accuracy across the study population. * Performance was notably strong in high-risk sub-groups, specifically individuals with obesity or sedentary lifestyles. ## AI-Driven Interpretation and Literacy * To assist with data translation, the researchers developed a prototype "Insulin Resistance Literacy and Understanding Agent" built on the Gemini family of large language models. * The agent is designed to help users interpret their IR risk predictions and provide personalized, research-backed educational content. * This AI integration aims to facilitate better communication between the data results and actionable health strategies, though it is currently intended for informational and research purposes. By utilizing ubiquitous wearable technology and existing clinical infrastructure, this approach offers a path toward proactive metabolic health monitoring. Integrating these models into consumer or clinical platforms could lower the barrier to early diabetes intervention and enable more personalized preventative care.

AI Large Language Models Machine Learning Gemini+4

figmaAug 5, 20253 min readCurated summary

Design Systems And AI: Why MCP Servers Are The Unlock | Figma Blog

Design systems provide the shared language AI agents need to generate code that is not merely functional, but consistent with a company’s brand, accessibility standards, and engineering practices. Figma argues that its MCP server unlocks this value by transferring design context—such as components, variables, styles, and code mappings—directly into developer workflows. The result is a feedback loop in which stronger design systems produce better AI output, while AI makes those systems more useful and scalable. ## Design Systems as Context for AI - Design systems already connect design and engineering through: - Shared patterns and terminology - Documentation and best practices - Brand guidelines and reusable code - These same elements give AI agents the context required to produce the “right” output rather than generic interfaces. - A mature design system can therefore become a productivity multiplier for AI-powered product development. - Organizations without a robust system can also use Figma’s MCP server to help implement tokens and components. ## Design Systems as the Shared Language - As AI lowers the barrier between ideas and implementation, product differentiation increasingly depends on craft, visual identity, and user experience. - Design systems help scale that craft while preserving speed, quality, and consistency. - Effective systems provide: - **Scalable foundations:** Tokens for color, spacing, typography, and other design decisions - **Reusable components:** Flexible elements built around a shared source of truth - **Built-in accessibility:** Inclusive experiences by default - They also prevent teams from shipping interchangeable, generic interfaces assembled from common AI-generated parts. ## Why Context Improves AI Code Generation - Figma reports that 68% of developers use AI to write code, but only 32% trust its output. - Without design-system context, AI behaves like a new engineer who has not been onboarded: its code may work, but it may not follow team conventions. - With that context, AI can: - Reuse existing components and patterns - Apply design tokens consistently - Generate higher-quality starting code - Reduce misunderstandings and shorten design-engineering feedback loops ## How Figma’s MCP Server Works - When developers inspect a Figma frame, the MCP server sends relevant context to an AI agent, including: - Components - Styles - Variables - Variable code syntax - **Code Connect** can map design elements to real code resources, allowing agents to use existing implementation libraries. - Even without these mappings, the server supplies styling information that helps agents create more design-informed code. - Automated design-system rule generation can scan a codebase and produce a structured rules file covering: - Token definitions - Component libraries - Style hierarchies - Naming conventions - This file gives AI agents system-level defaults, reducing the need for developers to repeat detailed instructions in every prompt. - Figma MCP also provides annotations that can communicate extra context, including accessibility and interaction behavior. ## The Design-System and AI Flywheel - Better design systems provide richer context to AI agents. - Better context leads to more accurate, on-brand code. - Improved AI output can make design-system adoption and maintenance more valuable. - This creates a reinforcing cycle: robust systems improve AI results, and AI helps teams apply and extend those systems more effectively. Teams seeking reliable AI-generated product code should treat their design system as essential infrastructure and connect it to development tools through mechanisms such as MCP, Code Connect, tokens, rules, and annotations.

Read original

Figma Design Systems AI Agents Model Context Protocol+2

googleAug 5, 2025Original article

Highly accurate genome polishing with DeepPolisher: Enhancing the foundation of genomic research (opens in new tab)

DeepPolisher is a deep learning-based genome assembly tool designed to correct base-level errors with high precision, significantly enhancing the accuracy of genomic research. By leveraging a Transformer architecture to analyze sequencing data, the tool reduces total assembly errors by 50% and insertion or deletion (indel) errors by 70%. This advancement is critical for creating near-perfect reference genomes, such as the Human Pangenome Reference, which are essential for identifying disease-causing variants and understanding human evolution. ## Limitations of Current Sequencing Technologies * Genome assembly relies on reading nucleotides (A, T, G, and C), but the microscopic scale of these base pairs makes accurate, large-scale sequencing difficult. * Short-read sequencing methods provide high signal strength but are limited to a few hundred nucleotides because identical DNA clusters eventually desynchronize, blending signals together. * Long-read technologies can sequence tens of thousands of nucleotides but initially suffered from high error rates (~10%); while tools like DeepConsensus have reduced this to 0.1%, further refinement is necessary for high-fidelity reference genomes. * Even a 0.1% error rate results in millions of inaccuracies across the 3-billion-nucleotide human genome, which can cause researchers to miss critical genetic markers or misidentify proteins. ## DeepPolisher Architecture and Training * DeepPolisher is an open-source pipeline adapted from the DeepConsensus model, utilizing a Transformer-based neural network. * The model was trained using a human cell line from the Personal Genomes Project that is estimated to be 99.99999% accurate, providing a "ground truth" for identifying and correcting errors. * The system takes sequenced bases, their associated quality scores, and the orientation of the DNA strands to learn complex error patterns that traditional methods might miss. * By combining sequence reads from multiple DNA molecules of the same individual, the tool iteratively "polishes" the assembly to reach the accuracy required for reference-grade data. ## Impact on Genomic Accuracy and Gene Discovery * The tool’s ability to reduce indel errors by 70% is particularly significant, as these specific errors often interfere with the identification of protein-coding genes. * DeepPolisher has already been integrated into major research efforts, including the enhancement of the Human Pangenome Reference, providing a more robust foundation for clinical diagnostics. * Improved assembly accuracy allows for better mapping of regions where the genome is highly repetitive, which were previously difficult to sequence and assemble confidently. For researchers and bioinformaticians, DeepPolisher represents a vital step in moving from "draft" genomes to high-fidelity references. Adopting this tool in assembly pipelines can drastically improve the reliability of variant calling and gene annotation, especially in complex clinical and evolutionary studies.

AI Deep Learning Transformer Genomics+4

datadogAug 4, 20251 min readCurated summary

Evolving our real-time timeseries storage again: Built in Rust for performance at scale | Datadog

The provided content does not include the tech blog post itself. It contains Datadog’s navigation menu and a link to an engineering article titled “Rust Timeseries Engine,” but no article text to summarize. Please provide the blog post content or its URL, and I can summarize it in the requested format.

Read original

Observability Rust Time Series Database Database Engine

datadogAug 4, 20254 min readCurated summary

Evolving our real-time timeseries storage again: Built in Rust for performance at scale

Datadog built a sixth-generation real-time timeseries database in Rust to keep pace with rapidly growing metric volume, cardinality, and query complexity. The new engine is designed for high throughput and low latency, reportedly achieving 60× higher ingestion performance and 5× faster peak-scale queries. Its development reflects a long evolution from general-purpose databases toward a purpose-built system with tighter control over storage, I/O, and execution. ## Datadog’s Metrics Storage Architecture - The metrics platform includes ingestion, enrichment, real-time and long-term storage, querying, and alerting. - This post focuses on real-time storage, which is split into two independently deployed services: - **RTDB:** Stores raw metric tuples of `<timeseries_id, timestamp, value>`, performs aggregations, and serves recent data. - **Index database:** Stores metric identifiers and their tags as `<timeseries_id, tags>`. - A storage router distributes incoming metrics across RTDB nodes based on load. - The query service contacts the relevant RTDB and index nodes, retrieves results, and combines them. - Each RTDB node includes: - An ingestion subsystem - A storage engine - A durability snapshot module - A gRPC query layer - Throttlers for resource management - A shared control plane coordinating these components ## Generation 1: Cassandra - Cassandra provided strong write scalability and a familiar operational model. - It was influenced by systems such as OpenTSDB and HBase. - Its main weaknesses were: - Limited flexibility for real-time queries - Difficulty supporting complex alerting and analytical workloads - Inefficient retrieval of large datasets - These limitations prompted Datadog to move to Redis. ## Generation 2: Redis - Redis improved read performance and offered a flexible, easy-to-understand storage model. - Datadog avoided Redis’s built-in clustering for reliability reasons, requiring the team to operate many independent instances. - Important drawbacks included: - Single-threaded execution limiting snapshotting during live traffic - Severe but uncommon memory-management and threading failures - Serialization and cross-process communication overhead - Inefficient memory layout, disk I/O, and CPU usage at scale - Redis nevertheless provided valuable operational insight and clarified the need for a purpose-built engine with direct control over I/O and system resources. ## Generation 3: MDBM and Memory-Mapped I/O - MDBM provided a memory-mapped key-value store based on `mmap`. - The operating system’s page cache loaded database pages on demand, making disk-backed data behave similarly to in-memory structures. - This simplified storage interactions initially, but performance degraded as workloads intensified. - Memory-mapped I/O introduced subtle performance and correctness concerns, leading Datadog to conclude that explicit I/O management would scale better. ## Generation 4: A Go-Based B+ Tree - Datadog replaced MDBM with a custom B+ tree written in Go. - The engine supported a thread-per-core-oriented design, with Go’s scheduler providing a useful foundation. - This change significantly improved throughput and latency. - It also created a platform that could be optimized more aggressively for Datadog’s workload. ## Generation 5: DDSketch and RocksDB - Datadog introduced DDSketch to support distribution metrics and accurate percentile estimation. - The existing Go engine was optimized for scalar floating-point values and was difficult to extend for sketches. - RocksDB was therefore integrated to store DDSketch data, offering flexibility and strong performance. - Over time, maintaining separate storage technologies created pressure to build a unified engine capable of handling multiple metric types efficiently. ## The Move Toward a New Engine - The progression from Cassandra to Redis, MDBM, a custom Go B+ tree, and RocksDB shows a pattern of replacing general-purpose components as scale and workload diversity increased. - Each generation solved important problems but introduced new operational or architectural trade-offs. - Datadog ultimately needed a unified, purpose-built storage system with: - High-throughput ingestion - Low-latency queries - Better support for high-cardinality data - Efficient handling of different metric types - More direct control over concurrency, memory, and I/O - The sixth generation addresses these requirements through a Rust-based real-time timeseries database. Datadog’s experience suggests that general-purpose storage systems can be effective early on, but sustained growth eventually favors a specialized engine. The practical lesson is to optimize existing infrastructure first while developing a purpose-built replacement before scale and workload complexity make incremental fixes insufficient.

Read original

Database Design Rust Redis Grpc+4

discordAug 3, 20253 min readCurated summary

Discord Patch Notes: August 4, 2025

Discord’s August 4, 2025 patch focuses on reliability, responsiveness, search, and cross-platform usability. Major updates improve Android keyboard behavior, media downloads, Tumblr embeds, thread search, pinned-message limits, and settings navigation during calls. The release also addresses numerous platform-specific bugs affecting navigation, rendering, notifications, accessibility, and server administration. ## Search, Media, and Content Improvements - Search now includes messages inside threads. - Thread names can be autocompleted with the `in:` search filter. - Embedded images and videos from other platforms download more reliably. - Downloaded media should no longer produce malformed filenames such as `@jpeg.bin.jpg`. - Tumblr links now receive properly formatted embeds, including Tumblr-hosted sites on custom domains. - The maximum number of pinned messages per channel increased from 50 to 250. ## Android and Mobile Usability - Android keyboard handling was improved, especially when switching between emoji input, the gallery, and the system keyboard. - Fixed cases where the keyboard covered messages or obscured too much of the interface on Android multitasking and foldable devices. - iOS received fixes for search crashes, emoji cropping, search-filter suggestions, Friends-list icon padding, and custom-status alignment. - Back gestures on mobile no longer incorrectly navigate from channel settings all the way back to chat. - Server Onboarding backgrounds, popups, and state retention were corrected across mobile flows. ## Desktop and Apple Platform Integrations - On desktop, User Settings now opens directly to Voice & Video when the user is in a call. - macOS Spotlight can now locate Discord channels by channel or server name. - Apple Handoff lets users move directly to a Discord channel from an iPad, Mac Dock, or iOS app switcher. - Desktop notifications now navigate correctly to Discord. - The system tray icon should remain visible after desktop updates. - Fixed PiP settings appearing behind the picture-in-picture window. ## Performance and Reliability - Discord improved GDM search, direct-message cleanup, and relationship-operation handling for accounts with extremely large amounts of data. - These changes target severe startup and application slowdowns experienced by heavy-utilization users. - Numerous crashes, rendering problems, and unreliable interactions were fixed across desktop, Android, and iOS. ## Server, Role, and Moderation Fixes - Roles can now be deleted from the right-click menu in Role Settings. - Mobile role sorting works again. - Pending friend requests are visible in desktop user profiles. - Audit-log entries for Android voice-channel statuses now use the correct icon. - Server invite dialogs once again show the username being used to accept an invitation. - Server template names that are too short now produce an informative error. - Mod View dates now respect the configured date format instead of always using `MM/DD/YYYY`. - Server Onboarding dismissal state is preserved when navigating away and returning. ## Rendering, Text, and Interface Corrections - Japanese channel names and Burmese Unicode text now render and transmit correctly. - Fixed blank reaction emojis, cropped iOS emojis, masked links in mobile event descriptions, and duplicated users in member lists. - Corrected alignment and padding issues across buttons, role displays, search controls, badges, popups, Clips, and subscription flows. - Username autocomplete is less aggressive and no longer locks onto the first matching result. - Discoverable-server globe icons, boosting icons, and official badges are now positioned correctly. - Student Hub menus, voice-message volume sliders, and invite-permission messaging were repaired or clarified. Overall, this release is primarily a broad maintenance update. Users with heavy Discord accounts, Android keyboard issues, thread-search needs, or frequent cross-device use should benefit most, while the many smaller fixes improve consistency across Discord’s platforms.

Read original

Discord Android iOS Macos+3

figmaAug 3, 20252 min readCurated summary

Who Says Design Needs a Mouse? | Figma Blog

Figma is introducing keyboard accessibility features to make end-to-end design possible without a mouse. Developed with feedback from keyboard- and screen-reader users, the updates improve canvas navigation, object insertion, and selection while providing better spoken feedback. The goal is to remove barriers so more designers can participate fully in design work. ## Keyboard-Only Canvas Navigation - Users can pan across the canvas with the arrow keys. - Holding `Shift` enables faster movement or scrolling. - New shortcuts provide finer zoom control and access to the move and hand tools. - These changes address problems such as getting stuck at the top of the canvas or zooming into the wrong area. ## Inserting Objects Without a Mouse - Most object types, including shapes and text, can now be added using the keyboard. - Frames can be inserted with keyboard shortcuts through a crosshair-guided view. - Pressing `Enter` places text in the center of the current screen. ## Selecting and Positioning Objects - A keyboard box-selection tool allows users to select objects on the canvas. - Arrow keys move a pink cursor between objects. - Pressing `Enter` selects the object under the cursor. - Multiple objects can be selected using a selection box. ## Broader Accessibility Improvements - Enhanced screen-reader support announces actions as users work, helping them stay oriented. - Figma’s accessibility efforts also include a color-picker contrast checker for evaluating WCAG compliance. - Semantic HTML tags can be assigned in designs to support products that work better with screen readers. - Figma emphasizes accessibility as an ongoing commitment rather than a one-time checklist. Users can consult Figma’s help center for instructions on using the new keyboard controls and enabling screen-reader support.

Read original

Figma Keyboard Navigation Wcag Screen Readers+2

lineAug 1, 2025Original article

Replacing the Payment System DB Handling (opens in new tab)

The LINE Billing Platform successfully migrated its large-scale payment database from Nbase-T to Vitess to handle high-traffic global transactions. While initially exploring gRPC for its performance reputation, the team transitioned to the MySQL protocol to ensure stability and reduce CPU overhead within their Java-based environment. This implementation demonstrates how Vitess can manage complex sharding requirements while maintaining high availability through automated recovery tools. ### Protocol Selection and Implementation - The team initially attempted to use the gRPC protocol but encountered `http2: frame too large` errors and significant CPU overhead during performance testing. - Manual mapping of query results to Java objects proved cumbersome with the Vitess gRPC client, leading to a shift toward the more mature and recommended MySQL protocol. - Using the MySQL protocol allowed the team to leverage standard database drivers while benefiting from Vitess's routing capabilities via VTGate. ### Keyspace Architecture and Data Routing - The system utilizes a dual-keyspace strategy: a "Global Keyspace" for unsharded metadata and a "Service Keyspace" for sharded transaction data. - The Global Keyspace manages sharding keys using a "sequence" table type to ensure unique, auto-incrementing identifiers across the platform. - The Service Keyspace is partitioned into $N$ shards using a hash-based Vindex, which distributes coin balances and transaction history. - VTGate automatically routes queries to the correct shard by analyzing the sharding key in the `WHERE` clause or `INSERT` statement, minimizing cross-shard overhead. ### MySQL Compatibility and Transaction Logic - Vitess maintains `REPEATABLE READ` isolation for single-shard transactions, while multi-shard transactions default to `READ COMMITTED`. - Advanced features like Two-Phase Commit (2PC) are available for handling distributed transactions across multiple shards. - Query execution plans are analyzed using `VEXPLAIN` and `VTEXPLAIN`, often managed through the VTAdmin web interface for better visibility. - Certain limitations apply, such as temporary tables only being supported in unsharded keyspaces and specific unsupported SQL cases documented in the Vitess core. ### Automated Operations and Monitoring - The team employs VTOrc (based on Orchestrator) to automatically detect and repair database failures, such as unreachable primaries or replication stops. - Monitoring is centralized via Prometheus, which scrapes metrics from VTOrc, VTGate, and VTTablet components at dedicated ports (e.g., 16000). - Real-time alerts are routed through Slack and email, using `tablet_alias` to specifically identify which MySQL node or VTTablet is experiencing issues. - A web-based recovery dashboard provides a history of automated fixes, allowing operators to track the health of the cluster over time. For organizations migrating high-traffic legacy systems to a cloud-native sharding solution, prioritizing the MySQL protocol over gRPC is recommended for better compatibility with existing application frameworks and reduced operational complexity.

Database Design Grpc Mysql Database Migration+4

figmaJul 31, 20252 min readCurated summary

The Duolingo Method: Collaboration As A Core Practice | Figma Blog

The Duolingo Math team treats collaboration as a continuous practice rather than a one-time handoff from design to engineering. Designers, engineers, and product managers co-create ideas, validate them through rapid prototypes, and refine features together. This approach helps the team make better decisions quickly while building entirely new learning experiences. ## Ideating Together - The Math team develops new lessons and games without established templates or patterns to follow. - Designers, engineers, and product managers begin projects together in a shared FigJam file. - After agreeing on a direction, designers create detailed Figma mockups, including interactions and motion. - Engineers participate early by evaluating technical complexity and commenting on implementation challenges. - Jira is connected directly to Figma, reducing context switching during development. ## Experimenting Through Rapid Prototyping - Engineers quickly build initial prototypes using components from Duolingo’s design system. - Designers and engineers share Figma files, working prototypes, questions, and feedback in Slack. - The team repeats a “prototype, test, tweak” cycle for each feature. - Duolingo’s “show don’t tell” principle encourages building and experiencing ideas instead of debating them abstractly. - Prototypes reveal how an interaction actually feels, helping the team test assumptions and make decisions before investing in a polished implementation. ## Polishing and Shipping Together - Continuous collaboration allows the team to make decisions and polish features during development. - The team may simplify animations or remove nonessential mechanics to ship faster. - When exploring educational games, Duolingo first created a batch of simple prototypes instead of building two fully developed games. - The team tested seven different prototypes to learn what resonated with users and prioritized features based on those findings. The Duolingo method replaces rigid handoffs with shared ownership, frequent communication, and working software. For exploratory products, teams should involve engineers early, prototype quickly, and use real user or team feedback to guide what gets polished and shipped.

Read original

Figma Design Systems Figjam Slack+3