Code Impact

This paper details the evolution of Google's Spanner, a globally-distributed database system, from a key-value store to a fully-fledged SQL system. Key improvements discussed include distributed query execution, handling of transient failures via query restarts, efficient range extraction for data retrieval, and the adoption of a common SQL dialect. The authors also explain the transition from a Bigtable-like storage format to a more efficient blockwise-columnar store (Ressi). Finally, the paper highlights lessons learned during Spanner's large-scale deployment and outlines remaining challenges.

The article explores Change Data Capture (CDC), a method for tracking database changes, highlighting its advantages over traditional daily snapshots. It details three CDC implementation approaches: using database triggers (e.g., in PostgreSQL), capturing API requests and using a message broker (e.g., Kafka), and leveraging change streams within a data warehouse (e.g., Snowflake). The article compares these methods, weighing their pros and cons in terms of performance, scalability, and ease of implementation. A subsequent discussion critiques the presented methods, suggesting alternative, more robust solutions based on logical replication tools like Debezium.

This research paper introduces DeepSeek-R1, a large language model enhanced for reasoning capabilities using reinforcement learning (RL). Two versions are presented: DeepSeek-R1-Zero, trained purely via RL without supervised fine-tuning, and DeepSeek-R1, which incorporates additional multi-stage training and cold-start data for improved readability and performance. DeepSeek-R1 achieves results comparable to OpenAI's o1-1217 on various reasoning benchmarks. The study also explores distilling DeepSeek-R1's reasoning capabilities into smaller, more efficient models, achieving state-of-the-art results. Finally, the paper discusses unsuccessful attempts using process reward models and Monte Carlo Tree Search, providing valuable insights for future research. https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf

This Atlassian blog post details the migration of Jira Cloud's Issue Service from JSON to Protocol Buffers (Protobuf) to enhance performance. The switch involved a phased approach to minimise downtime, creating new endpoints and logic to handle both formats concurrently before a complete transition. The results showcased significant improvements: 75% less Memcached CPU usage, 80% smaller data size, and a substantially faster response time. Challenges encountered included Protobuf's handling of null values and incompatibility with Spring's default error controller, which required workarounds. Ultimately, the migration yielded substantial performance gains and reduced infrastructure needs. https://www.atlassian.com/blog/atlassian-engineering/using-protobuf-to-make-jira-cloud-faster

This research paper introduces Hyaline, a novel family of memory reclamation schemes for lock-free data structures in unmanaged C/C++ code. Hyaline leverages reference counting, but only during reclamation, minimising overhead during object access and balancing workload across threads. The paper details Hyaline's design, including a scalable multi-list version and robust extensions to handle stalled threads. Extensive testing across multiple architectures demonstrates Hyaline's superior performance and memory efficiency compared to existing schemes like epoch-based reclamation and hazard pointers, particularly in read-dominated and oversubscribed scenarios. The paper concludes by proving Hyaline's correctness and lock-freedom properties.

This Atlassian blog post details Trello's migration from RabbitMQ to Kafka for its websocket architecture. RabbitMQ's unreliability during network partitions and high costs associated with queue creation and deletion prompted the switch. The article compares various queuing systems, highlighting Kafka's superior failover capabilities and in-order message delivery. Trello implemented a master-client architecture with Kafka, resulting in improved performance, reduced costs, and fewer outages. Key performance improvements included a 33% decrease in memory usage and a substantial cost reduction.

This podcast explores the field of reliability engineering, tracing its origins at Google with the development of Site Reliability Engineering (SRE). It differentiates reliability engineering from SRE, highlighting its broader applicability across various organisational structures. The podcast outlines four key promises of a successful reliability team: defining service levels (SLA/SLO/SLI), managing the service infrastructure, participating in technical design, and providing tactical support during incidents. Finally, it discusses the evolving landscape of reliability engineering, emphasising pragmatic approaches to balancing cost and reliability needs, and advocating for a more nuanced understanding of when to build versus buy solutions.

This podcast profiles Antithesis, a company developing a "multiverse debugger" for large, distributed systems. It traces the history of debugging tools, highlighting Antithesis's innovative approach using deterministic simulation testing (DST) to allow time travel debugging. The podcast includes a Q&A with Antithesis's co-founder, detailing the challenges of debugging large systems and how Antithesis addresses them. Furthermore, it discusses Antithesis's tech stack, engineering culture, and the trade-offs of using their complex, but potentially game-changing, technology. Finally, it considers the implications of widespread adoption of Antithesis's technology for the future of software development.

This podcast details the creation of Shopify's interactive Black Friday/Cyber Monday live dashboard, nicknamed "Live Globe". The 2024 version, built by a six-person team in two months, features a spaceship-themed interface showcasing real-time sales data and boasts impressive technical specifications, including peak loads of nearly 30 million database reads per second. The design process involved extensive prototyping and the use of AI-generated imagery for inspiration. The podcast also highlights the technology stack (React Three Fiber, Go, Rails, Kafka, and Flink), the inclusion of numerous Easter eggs, and the challenges of performance optimisation and real-time data streaming. Finally, it explores the project's unique approach to ROI, prioritising fun and innovation.

This podcast examines the contrasting "wartime" and "peacetime" operating modes in tech companies, drawing on the author's experiences at Uber and observations across the industry. It defines these modes in terms of leadership styles, employee behaviours, and organisational priorities, highlighting the differences in approaches to project management, performance reviews, and tech debt. The text explores the transitions between these modes, identifying common triggers and observable signs, and offers advice for employees and managers on thriving in each environment. Finally, it discusses the counterintuitive relationship between extended "wartime" periods and tech debt accumulation.

Jim McCormick's "The First Time Manager" offers a practical guide for new managers, covering essential aspects like communication, delegation, and conflict resolution. The book employs a clear and relatable style, using real-world examples and actionable advice to help readers build foundational leadership skills. While some advice may be general, its comprehensive approach to fundamental management principles makes it a valuable resource for aspiring and new managers seeking a strong start in their careers. The book also touches on crucial aspects of personal development and emotional intelligence in leadership. Even experienced managers might find its refresher on core concepts beneficial.

This research paper details the development and implementation of efficient techniques for processing multiple, similar aggregate queries in data streaming systems. The authors address the challenges of scaling to handle hundreds of concurrent queries, each with potentially different time windows and selection predicates. Their proposed "on-the-fly" methods avoid computationally expensive static query analysis, offering significant performance improvements (up to an order of magnitude) over existing approaches. The techniques are validated through a performance study using real-world stock market data, demonstrating their practical effectiveness. The core contributions are novel algorithms for shared time slices, shared data fragments, and a combined approach called shared data shards.

The article details how Vercel's platform handles web requests, from initial user input to final response. Vercel's Edge Network directs requests to optimal data centres, minimising latency. A multi-layered firewall system protects against threats. Advanced routing features, including middleware, manage request flow. Finally, Edge caching and Vercel Functions optimise speed and scalability for dynamic content.

This research paper introduces Monolith, a real-time recommendation system designed by Bytedance. Addressing limitations of existing deep learning frameworks, Monolith uses a novel collisionless embedding table to efficiently handle sparse, dynamic features, significantly improving model quality and memory usage. A key innovation is its online training architecture, enabling real-time model updates based on user feedback. The authors demonstrate Monolith’s superior performance through experiments and A/B tests, highlighting the trade-offs between real-time learning and system reliability. Finally, the paper compares Monolith to existing solutions, showcasing its advantages in scalability and efficiency for large-scale recommendation tasks.

This article reminisces on the history of the Postgres project, spearheaded by Michael Stonebraker at UC Berkeley from the mid-1980s to the mid-1990s. It details Stonebraker's design philosophy and the project's technical innovations, including support for abstract data types, active databases, and novel storage and recovery mechanisms. The article highlights Postgres's evolution into the open-source PostgreSQL system, its significant commercial impact through various spin-off companies, and the lessons learned from its success. It also discusses the unexpected benefits of open-sourcing the research and the project's lasting influence on database technology. The author reflects on his own involvement and contributions to the project.

This blog post details Yelp's in-place migration of their Yelp Reservations service database from PostgreSQL to MySQL. The migration, necessitated by maintenance and expertise limitations with PostgreSQL, involved significant code refactoring to address unsupported features and ensure data consistency. A gradual rollout strategy, employing multi-DB support and careful synchronisation, was implemented to minimise disruption. The process revealed several unexpected challenges, including issues with auto-incrementing keys and ProxySQL memory usage, highlighting the complexities of such large-scale database migrations. Ultimately, the switch to the company standard MySQL improved performance and maintainability.

Meta's FBDetect system, detailed in this research paper, is a robust, in-production performance regression detection system. It identifies minuscule performance regressions (as small as 0.005%) across millions of servers and hundreds of services by monitoring hundreds of thousands of time series metrics. Key to FBDetect's success are advanced techniques for subroutine-level performance analysis, filtering false positives, deduplicating correlated regressions, and root cause analysis. The paper validates FBDetect's effectiveness through simulations and real-world production data, showcasing its superiority over existing methods and highlighting the significance of its seven years of successful operation.

This paper details the architecture and evolution of Amazon DynamoDB, a fully managed NoSQL database service. Key features highlighted include its scalability, predictable performance, high availability (achieved through multi-region replication and sophisticated failure handling), and strong durability (guaranteed by techniques like write-ahead logging and continuous data verification). The authors discuss challenges faced during DynamoDB's development, such as handling uneven traffic distribution and optimising resource allocation, and explain the solutions implemented, including the shift from provisioned to on-demand capacity. Performance benchmarks are provided to demonstrate the system's consistent low latency even under extreme load.

This blog post discusses the multifaceted definition of a senior software engineer. Technical expertise is crucial, encompassing a T-shaped skill profile and a deep understanding of software development principles. However, soft skills, such as communication, leadership, and a growth mindset, are equally vital for moving projects and teams forward. The author suggests several strategies for professional growth, including pair programming, content creation, and seeking challenging tasks. Ultimately, the article posits that becoming a senior engineer is an ongoing journey of learning and improvement, rather than a fixed destination.

Amazon Web Services (AWS) has launched Amazon S3 Tables, a new storage service optimised for analytical workloads. These tables, stored in a new type of S3 bucket, utilise the Apache Iceberg format for efficient querying with tools like Amazon Athena and Apache Spark. Offering significant performance improvements (up to 3x faster queries and 10x more transactions per second) over self-managed solutions, S3 Tables provide fully managed features including automatic compaction, snapshot management, and unreferenced file removal. The service integrates with other AWS analytics services and supports standard S3 APIs, offering enhanced security and scalability. Currently available in select US regions, S3 Tables are designed to streamline large-scale data analytics.

This transcript from an AWS re:Invent 2024 session details Amazon S3's architecture and engineering principles. Two senior engineers explain how S3's massive scale enables efficient data management, utilising techniques like shuffle sharding to distribute workloads across millions of drives. They discuss the physics of data storage, showcasing how S3's design improves performance and reliability by mitigating the impact of hardware limitations and individual workload bursts. Erasure coding is highlighted as a key technology that ensures data durability and facilitates faster software deployment. Finally, the presentation emphasises how S3's fault-tolerant design, built on principles of decorrelation, ultimately benefits customers by providing a consistently high-performing and reliable service.

This blog post by Marc Brooker, an AWS engineer, explains the write operations within Aurora DSQL, a scalable SQL database. It details how Aurora DSQL uses optimistic concurrency control (OCC) combined with multiversion concurrency control (MVCC) to achieve strong consistency and snapshot isolation. The system uses an "adjudicator" service to manage write conflicts and a "Journal" for durable, ordered data replication. The author highlights the benefits of this approach for scalability, availability, and performance, emphasising the avoidance of locking. Finally, the post touches upon the system's consistency guarantees and the importance of schema design to minimise write conflicts.

This research article details the development and benchmarking of a high-performance URL parser compliant with the WHATWG standard. The authors created a C++ implementation leveraging vectorisation techniques, resulting in a parser significantly faster than existing solutions like curl and rust-url. Their parser was integrated into Node.js, leading to substantial performance improvements in URL processing within that environment. Extensive benchmarks across various datasets and platforms demonstrated the superior speed and efficiency of their new parser. The authors also provide open-source access to their code and datasets.

This article presents technology predictions for 2025 and beyond, focusing on several key themes. Firstly, it highlights a growing mission-driven workforce prioritising positive societal impact over solely financial gain. Secondly, it discusses the crucial role of technological innovation in addressing the global energy crisis, advocating for a blend of renewable and nuclear solutions alongside improved energy consumption practices. Thirdly, the text explores the use of AI-powered tools to combat the spread of misinformation and disinformation. Finally, it examines the emerging trend of intention-driven consumer technology, emphasising mindful usage and a reduction in constant digital distraction.

This paper details the architecture and design of Amazon Aurora, a cloud-native relational database service. Key design choices focus on mitigating network bottlenecks inherent in high-throughput cloud systems by offloading redo processing to a separate, distributed storage service. This approach enhances durability and availability through a novel quorum model and segmented storage, significantly improving performance and reducing recovery times. The authors present performance benchmarks demonstrating Aurora's superior scalability and efficiency compared to traditional MySQL configurations, along with lessons learned from real-world customer deployments highlighting the system's suitability for modern cloud applications. Finally, the paper compares Aurora's design to related work in distributed database systems.

This research paper investigates the feasibility and limitations of using Amazon S3, a cloud storage service, as a database system for web applications. The authors present protocols for managing reads, writes, and commits to S3, addressing issues of concurrency and consistency. They explore different consistency levels, including eventual consistency and stronger guarantees like atomicity and monotonic reads/writes, analysing their performance and cost implications using the TPC-W benchmark. The study highlights the trade-offs between consistency, availability, and scalability inherent in utilising S3 for database applications and proposes solutions to enhance transactional properties while retaining S3’s inherent advantages. The paper concludes by discussing related work and future research directions.

This 2003 USENIX paper challenges the prevailing belief that event-based programming is superior to thread-based programming for high-concurrency servers. The authors argue that the perceived weaknesses of threads stem from flawed implementations rather than inherent limitations. They present a high-performance user-level thread package as evidence, supporting their claim that threads offer a simpler, more natural programming model. Furthermore, they propose compiler enhancements to further improve thread performance and safety. The paper compares and contrasts the two approaches, revisiting earlier work on their duality, and concludes that with proper compiler support, threads provide a superior solution for building scalable servers.

This Medium article by Shivam Bhadani provides a comprehensive guide to system design for beginners. It covers fundamental concepts like servers, latency, and throughput, progressing to advanced topics such as scaling strategies (vertical and horizontal), database scaling, microservices, caching, and message brokers. The author emphasises practical implementation alongside theory, using real-world examples and providing exercises to reinforce learning. The article concludes with advice on approaching system design problems and includes numerous illustrations. A strong focus is placed on distributed systems and their associated challenges, including consistency and leader election. Article: https://medium.com/@shivambhadani_/system-design-for-beginners-everything-you-need-in-one-article-c74eb702540b

This 1995 paper argues that threads, while powerful for achieving true CPU concurrency, are overly complex for most programming tasks. The author, John Ousterhout, contends that event-driven programming offers a simpler, more reliable alternative for applications such as GUIs and distributed systems. He highlights the difficulties of thread synchronisation, debugging, and performance optimisation, contrasting them with the relative ease of event handling. Ousterhout advocates using threads only when genuine parallel processing across multiple CPUs is essential, suggesting that even then, they should be confined to a core kernel within a predominantly single-threaded application. Ultimately, the paper promotes a pragmatic approach, prioritising simplicity and maintainability unless high-performance concurrency is absolutely necessary.

This paper examines SQLite, the world's most widely deployed database engine, exploring its history, architecture, and performance characteristics. The authors benchmark SQLite against DuckDB, an analytics-focused database, across various workloads (OLTP, OLAP, and blob processing). Key performance bottlenecks in SQLite's OLAP capabilities are identified and addressed through optimisation, resulting in significant speed improvements. The study also considers the resource footprint of both databases, comparing their compilation times, library sizes, and data storage efficiency. Finally, the authors discuss future development directions for SQLite, balancing performance enhancements with its established strengths of portability, compactness, and reliability.

This research paper introduces Prequal, a novel load balancer designed to minimise latency in large-scale distributed systems like YouTube. Unlike traditional load balancers that focus on balancing CPU usage, Prequal prioritises estimated latency and requests in flight, actively probing servers for real-time load information. Extensive testing on YouTube and a controlled testbed demonstrated that Prequal significantly reduces tail latency, error rates, and resource consumption, compared to weighted round-robin and other load balancing strategies. The paper details Prequal's design, including its asynchronous probing mechanism and hot-cold lexicographic rule for replica selection, and its superior performance is attributed to its ability to dynamically adapt to heterogeneous server capacities and varying workloads.

This document presents the June 2024 RedMonk Programming Language Rankings, which are based on data extracted from GitHub and Stack Overflow. The report, authored by Stephen O'Grady, provides an analysis of the most popular programming languages and their relative popularity, highlighting trends in language adoption. The rankings offer a glimpse into the dynamic world of software development and serve as a valuable resource for developers and organisations alike. Reference: https://redmonk.com/sogrady/2024/09/12/language-rankings-6-24/

Building a reliable microservices architecture requires careful consideration of data consistency. Join us as we explore event sourcing, a powerful pattern that ensures atomic updates across your database and message broker, eliminating data inconsistencies and paving the way for a robust and scalable system. Reference: https://microservices.io/patterns/data/event-sourcing.html

This podcast explores domain events and their crucial role in modern software architecture. Join us as we discuss how domain events facilitate communication between services, support patterns like CQRS and Saga, and enable the development of robust and scalable applications. We'll also examine related concepts like DDD aggregates, transactional outboxes, and event sourcing to provide a comprehensive understanding of this vital architectural pattern. Reference: https://microservices.io/patterns/data/domain-event.html

In this episode, we explore the Command Query Responsibility Segregation (CQRS) pattern, a powerful technique for implementing efficient queries in microservice architectures. We break down the challenges of querying data across multiple services and explain how CQRS offers a solution through the creation of dedicated read-only databases. Tune in to discover the benefits, drawbacks, and real-world examples of CQRS in action, helping you streamline data retrieval and enhance your microservices' performance. Reference: https://microservices.io/patterns/data/cqrs.html

Discover the API Composition pattern, its benefits, drawbacks, and practical examples using API Gateways. Learn about alternative solutions like the CQRS pattern and understand how it addresses the challenges posed by the Database per Service pattern. This podcast is your guide to efficient data management in a microservice world. Reference: https://microservices.io/patterns/data/api-composition.html

This podcast explores the world of microservices architecture, discussing patterns, benefits, and challenges. We'll cover topics like the Command-Side Replica pattern, Database per Service, and the Saga pattern. Learn how to design, implement, and manage complex systems using microservices. Join us as we break down the complexities of modern software development and empower you to build robust and scalable applications. Reference: https://microservices.io/patterns/data/command-side-replica.html

In the realm of microservices, where applications are split into independent services, managing transactions that span multiple services becomes a challenge. This episode explores the Saga pattern, a powerful solution for coordinating distributed transactions. Discover how Sagas break down complex operations into smaller, manageable local transactions, ensuring data consistency without relying on traditional distributed transaction mechanisms. Learn about the two main Saga coordination styles – choreography and orchestration – and their trade-offs. We'll also discuss the benefits and drawbacks of using Sagas, including strategies for handling failures and maintaining isolation. Reference: https://microservices.io/patterns/data/saga.html

Join us as we discuss the challenges of managing data in a microservices architecture. We'll focus on the "Shared Database" pattern, analysing its potential benefits and drawbacks, and providing insights to help you make informed architectural decisions for your applications. Reference: https://microservices.io/patterns/data/shared-database.html

In the world of microservices, data management is key. This episode explores the "Database-per-Service" pattern – a powerful approach to keeping your services loosely coupled and adaptable. We'll look at the benefits, drawbacks, and how to navigate challenges like distributed transactions and complex queries. Get ready to optimise your microservice architecture! Reference: https://microservices.io/patterns/data/database-per-service.html

This episode focuses on the Polling Publisher pattern, a crucial technique for publishing messages in a microservices architecture. Explore its workings, benefits, drawbacks, and alternatives like Transaction Log Tailing. Reference: https://microservices.io/patterns/data/polling-publisher.html

In this episode, we explore the Transaction Log Tailing pattern, a powerful technique for ensuring reliable message delivery in a microservices architecture. We'll discuss how this pattern works, its benefits and drawbacks, and how it compares to alternative solutions. Join us as we demystify transaction log tailing and unlock its potential for your microservices applications. References: https://microservices.io/patterns/data/transaction-log-tailing.html

While event sourcing is a popular approach for managing data consistency in microservices, there are alternative patterns worth considering. This episode explores the Transactional Outbox pattern, a versatile solution for reliably sending messages and events even when distributed transactions are not an option. Uncover the inner workings of this pattern and how it guarantees message ordering and delivery while maintaining the flexibility of your microservices architecture. Reference: https://microservices.io/patterns/data/transactional-outbox.html

In today's fast-paced business environment, agility is key. This podcast explores how microservices empower organisations to achieve rapid development cycles, adapt quickly to changing requirements, and maintain a competitive edge. Join us as we discuss the principles, practices, and real-world experiences of adopting microservices for increased agility. Reference: https://microservices.io/patterns/decomposition/service-per-team.html

Are you considering adopting microservices or looking to improve your existing architecture? This podcast is your one-stop shop for all things microservices. We discuss proven patterns, best practices, and common pitfalls to help you navigate the challenges of this architectural style. We'll cover topics such as service communication, data consistency, testing, deployment, and more, drawing on real-world experiences and industry insights. Reference: https://microservices.io/patterns/index.html

In the world of distributed systems, performance is paramount. Discover how the 'Consistent Core' pattern allows large data clusters to coordinate efficiently by leveraging a smaller, dedicated cluster for critical functions. We'll unpack the problem of quorum-based algorithms in large clusters and explain how 'Consistent Core' offers a practical alternative. Reference: https://martinfowler.com/articles/patterns-of-distributed-systems/consistent-core.html

In distributed systems, leadership can emerge organically without explicit elections. This podcast unpacks the "Emergent Leader" pattern, where the oldest node in a cluster naturally assumes the role of coordinator. We'll discuss how this approach simplifies coordination, enhances fault tolerance, and enables efficient decision-making in complex, decentralized environments. Tune in to understand the intricacies of this powerful pattern and its implications for modern system design. Reference: https://martinfowler.com/articles/patterns-of-distributed-systems/emergent-leader.html

Imagine a world where your online shopping experience becomes a confusing mess because different parts of the system can't agree on what time it is! This is the challenge of external consistency in distributed systems, and it's the topic of today's episode. We'll explore the Clock-Bound Wait pattern – a clever solution that ensures all nodes in a system are on the same page, time-wise, before reading or writing data. This episode will be particularly interesting for software developers, architects and anyone curious about the hidden complexities of building reliable distributed systems.

Ever wonder how Netflix manages to send real-time updates to a billion devices worldwide? This podcast explores the fascinating story of Pushy, Netflix's custom-built WebSocket server. We'll hear from the engineers who built and scaled Pushy, and learn about the technical challenges they faced along the way. We'll also explore the future of Pushy, and how it will continue to evolve to meet the needs of Netflix's growing user base. Reference: https://netflixtechblog.com/pushy-to-the-limit-evolving-netflixs-websocket-proxy-for-the-future-b468bc0ff658

In this episode, we explore the fascinating world of traffic replay at Netflix. Discover how this powerful technique allows engineers to simulate real-world scenarios, test new features at scale, and identify potential issues before they impact users. We'll examine the 'Basic with Ads' launch as a case study and discuss the broader applications of traffic replay in software development. Reference: https://netflixtechblog.com/ensuring-the-successful-launch-of-ads-on-netflix-f99490fdf1ba