There are many benefits to becoming a data-driven organization, including the ability to accelerate and improve business decision accuracy through the real-time processing of transactions, social media streams, and IoT data. But those benefits require significant changes to your infrastructure. You need flexible architectures that can copy data to analytics platforms at near-zero latency while maintaining 100% production uptime. Fortunately, a solution already exists.
This ebook demonstrates how change data capture (CDC) can meet the scalability, efficiency, real-time, and zero-impact requirements of modern data architectures. Kevin Petrie, Itamar Ankorion, and Dan Potter—technology marketing leaders at Attunity—explain how CDC enables faster and more accurate decisions based on current data and reduces or eliminates full reloads that disrupt production and efficiency.
The book examines:
How CDC evolved from a niche feature of database replication software to a critical data architecture building block
Architectures where data workflow and analysis take place, and their integration points with CDC
How CDC identifies and captures source data updates to assist high-speed replication to one or more targets
Case studies on cloud-based streaming and streaming to a data lake and related architectures
Guiding principles for effectively implementing CDC in cloud, data lake, and streaming environments
The Attunity Replicate platform for efficiently loading data across all major database, data warehouse, cloud, streaming, and Hadoop platforms

This practical book shows you how to use Operators to install some of the most essential core services on Kubernetes clusters with automated management and upgrades. Items such as permanent storage and databases can be complex to run on Kubernetes, because they often have their own notions of storage, networking, and clustering. Authors Josh Wood and Paul Bert explain how Operators know how to configure serious apps to work on your cluster, and how to keep them running over time, including upgrading them between versions.

Redis 是互联网技术架构在存储系统中使用得最为广泛的中间件，也是中高级后端工程师技术面试中面试官最喜欢问的工程技能之一，特别是那些优秀的互联网公司，通常要求面试者不仅仅掌握 Redis 基础用法，还要理解 Redis 内部实现的细节原理。《Redis 深度历险：核心原理与应用实践》作者老钱在使用 Redis 上积累了丰富的实战经验，希望帮助更多后端开发者更快、更深入地掌握 Redis 技能。
《Redis 深度历险：核心原理与应用实践》分为基础和应用篇、原理篇、集群篇、拓展篇、源码篇共 5 大块内容。基础和应用篇讲解对读者来说最有价值的内容，可以直接应用到实际工作中；原理篇、集群篇让开发者透过简单的技术表面看到精致的底层世界；拓展篇帮助读者拓展技术视野和夯实基础，便于进阶学习；源码篇让高阶的读者能够读懂源码，掌握核心技术实力。
《Redis 深度历险：核心原理与应用实践》适合以下人群阅读：有 Redis 基础，渴望深度掌握 Redis 技术原理的中高级后端开发者；渴望成功进入大型互联网企业研发部的中高级后端开发者；需要支撑公司 Redis 中间件运维工作的初中级运维工程师；对 Redis 中间件技术好奇的中高级前端技术研究者。

《深入理解Kafka：核心设计与实践原理》从Kafka的基础概念切入，循序渐进地转入对其内部原理的剖析。《深入理解Kafka：核心设计与实践原理》主要阐述了Kafka中生产者客户端、消费者客户端、主题与分区、日志存储、原理解析、监控管理、应用扩展及流式计算等内容。虽然Kafka的内核使用Scala语言编写，但《深入理解Kafka：核心设计与实践原理》基本以Java语言作为主要的示例语言，方便大多数读者的理解。虽然《深入理解Kafka：核心设计与实践原理》没有明确的界定，但总体上可以划分为三个部分：基础篇、原理篇和扩展篇，前4章为基础篇，包括基础概念、生产者、消费者，以及主题与分区，学习完这4章的内容完全可以应对绝大多数的开发场景。第5章至第8章为原理篇，包括对日志存储、协议设计、控制器、组协调器、事务、一致性、可靠性等内容的探究，学习完这4章的内容可以让读者对Kafka有一个深刻的认知。最后4章从应用扩展层面来做讲解，可以归类为扩展篇，主要内容包括监控、应用工具、应用扩展（延时队列、重试队列、死信队列、消息轨迹等）、与Spark的集成等，让读者可以对Kafka的生态有一个更加全面的认知。
《深入理解Kafka：核心设计与实践原理》定位为一本实战与原理相结合的书，既适合Kafka的初学者，也适合于对Kafka有一定深度认知的老手。

Summary
Secure by Design teaches developers how to use design to drive security in software development. This book is full of patterns, best practices, and mindsets that you can directly apply to your real world development. You'll also learn to spot weaknesses in legacy code and how to address them.
Foreword by Daniel Terhorst-North.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Security should be the natural outcome of your development process. As applications increase in complexity, it becomes more important to bake security-mindedness into every step. The secure-by-design approach teaches best practices to implement essential software features using design as the primary driver for security.
About the Book
Secure by Design teaches you principles and best practices for writing highly secure software. At the code level, you'll discover security-promoting constructs like safe error handling, secure validation, and domain primitives. You’ll also master security-centric techniques you can apply throughout your build-test-deploy pipeline, including the unique concerns of modern microservices and cloud-native designs.
What's inside
Secure-by-design concepts
Spotting hidden security problems
Secure code constructs
Assessing security by identifying common design flaws
Securing legacy and microservices architectures
About the Reader
Readers should have some experience in designing applications in Java, C#, .NET, or a similar language.

A quorum system is a collection of subsets of nodes, called quorums, with the property that each pair of quorums have a non-empty intersection. Quorum systems are the key mathematical abstraction for ensuring consistency in fault-tolerant and highly available distributed computing. Critical for many applications since the early days of distributed computing, quorum systems have evolved from simple majorities of a set of processes to complex hierarchical collections of sets, tailored for general adversarial structures. The initial non-empty intersection property has been refined many times to account for, e.g., stronger (Byzantine) adversarial model, latency considerations or better availability. This monograph is an overview of the evolution and refinement of quorum systems, with emphasis on their role in two fundamental applications: distributed read/write storage and consensus.
Table of Contents: Introduction / Preliminaries / Classical Quorum Systems / Classical Quorum-Based Emulations / Byzantine Quorum Systems / Latency-efficient Quorum Systems / Probabilistic Quorum Systems

As Python continues to grow in popularity, projects are becoming larger and more complex. Many Python developers are now taking an interest in high-level software architecture patterns such as hexagonal/clean architecture, event-driven architecture, and strategic patterns prescribed by domain-driven design (DDD). But translating those patterns into Python isn’t always straightforward.
With this practical guide, Harry Percival and Bob Gregory from MADE.com introduce proven architectural design patterns to help Python developers manage application complexity. Each pattern is illustrated with concrete examples in idiomatic Python that explain how to avoid some of the unnecessary verbosity of Java and C# syntax. You’ll learn how to implement each of these patterns in a Pythonic way.
Architectural design patterns include:
Dependency inversion, and its links to ports and adapters (hexagonal/clean architecture)
Domain-driven design’s distinction between entities, value objects, and aggregates
Repository and Unit of Work patterns for persistent storage
Events, commands, and the message bus
Command Query Responsibility Segregation (CQRS)
Event-driven architecture and reactive microservices

Have you, like the rest of the world, speculated as to the identity of Satoshi Nakamoto, anonymous creator of Bitcoin?
The world’s first cryptocurrency, Bitcoin went online in 2009 and has since revolutionized our concepts of currency and money. Not supported by any government or central bank, completely electronic, Bitcoin is a virtual currency based on advanced cryptographic systems.
Like the currency he created, the identity of Bitcoin’s creator Satoshi Nakamoto is virtual, existing only online. The Nakamoto persona, which may represent an individual or a group, exists only in the online publications that introduced and explained Bitcoin during its earliest days. Here, collected and professionally published for the first time are the essential writings that detail Bitcoin’s creation.
Included are
Satoshi Nakamoto Emails and Posts on Computer Forums Presented in Chronological Order
Bitcoin Fundamentals Presented in Layman’s Terms
Bitcoin’s Potential and Profound Economic Implications
The Seminal Paper Which Started It All
The Book of Satoshi provides a convenient way to parse through what Bitcoin’s creator wrote over the span of the two years that constituted his “public life" before he disappeared from the Internet ... at least under the name Satoshi Nakamoto. Beginning on November 1st 2009 with the publication of the seminal paper describing Bitcoin, this public life ends at about the time PC World speculated as to a possible link between Bitcoin and WikiLeaks, the infamous website that publishes leaked classified materials. Was there a connection? You be the judge.
Nakamoto’s true identity may never be known. Therefore the writings reproduced here are probably all the world will ever hear from him concerning Bitcoin’s creation, workings, and theoretical basis. Want to learn more about Bitcoin? Go directly to the source—the writings of the creator himself, Satoshi Nakamoto!

Learn You a Haskell for Great Good! is a fun, illustrated guide to learning Haskell, a functional programming language that's growing in popularity. Learn You a Haskell for Great Good! introduces programmers familiar with imperative languages (such as C++, Java, or Python) to the unique aspects of functional programming. Packed with jokes, pop culture references, and the author's own hilarious artwork, Learn You a Haskell for Great Good! eases the learning curve of this complex language, and is a perfect starting point for any programmer looking to expand his or her horizons. The well-known web tutorial on which this book is based is widely regarded as the best way for beginners to learn Haskell, and receives over 30,000 unique visitors monthly.
About the Author
Miran Lipovaca is a computer science student in Ljubljana, Slovenia. His online tutorial, "Learn You a Haskell for Great Good!," is widely regarded as the best way to learn Haskell.

Microservices fundamentally change the way you design enterprise software. By adding network dependencies to your application logic, you invite in a host of potential hazards that grow proportionally with the number of connections you make. With the updated edition of this practical ebook, application architects and development team leads will learn how to use the Istio service mesh to connect, manage, and secure microservices in order to create powerful cloud-native applications.
Burr Sutter and his team at Red Hat introduce you to several key microservices capabilities that Istio provides on top of Kubernetes and OpenShift. You’ll learn how your application can offload service discovery, load balancing, resilience, observability, and security to Istio so you can focus on differentiating business logic.
Dive into Istio with detailed examples of:
Traffic control: Examine Istio patterns including smarter canaries and dark launches
Service resiliency: Discover how Istio provides load balancing, circuit breaking, and pool ejection
Chaos testing: Test your system’s ability to withstand turbulent conditions through fault injection
Observability: Use tracing and metrics to learn the relationships between individual system components
Security: Explore Istio’s security capabilities, such as mTLS, RBAC, and policy enforcement

Distributed systems have become more fine-grained in the past 10 years, shifting from code-heavy monolithic applications to smaller, self-contained microservices. But developing these systems brings its own set of headaches. With lots of examples and practical advice, the second edition of this practical book takes a holistic view of the topics that system architects and administrators must consider when building, managing, and evolving microservice architectures.
Microservice technologies are moving quickly, and this revised edition gets you up to date with a new chapter on serverless and cloud-native applications, expanded coverage of user interfaces, more hands-on code examples, and other additions throughout the book.
Author Sam Newman provides you with a firm grounding in the concepts while diving into current solutions for modeling, integrating, testing, deploying, and monitoring your own autonomous services. You’ll follow a fictional company throughout the book to learn how building a microservice architecture affects a single domain.

Can a system ever truly be considered reliable if it isn't fundamentally secure? In two previous O'Reilly books, experts from Google showed how reliability is fundamental to service design. Site Reliability Engineering and The Site Reliability Workbook demonstrated how and why a commitment to the entire service lifecycle enables organizations to successfully build, deploy, monitor, and maintain software systems.
Security is also crucial to the design and operation of scalable systems in production, as it plays an important part in product quality, performance, reliability, and availability. In a world where most products are connected to the internet, and with cloud technologies and machine learning becoming more prevalent, enabling security by default is increasingly important.
This book shares best practices to help an organization of any size design scalable and reliable systems that are fundamentally secure. It also offers insights into how teams across an organization can collaborate on security and reliability.
Specifically, you'll learn about:
Design Strategies
Implementation & Operations
Preparing for the Worst: Detection & Response
Scaling Security and the Organization

Get a comprehensive understanding of gRPC fundamentals through real-world examples. With this practical guide, you’ll learn how this high-performance interprocess communication protocol is capable of connecting polyglot services in microservices architecture, while providing a rich framework for defining service contracts and data types.
Complete with hands-on examples written in Go, Java, Node, and Python, this book also covers the essential techniques and best practices to use gRPC in production systems. Authors Kasun Indrasiri and Danesh Kuruppu discuss the importance of gRPC in the context of microservices development.

Learn how to design, develop, and deploy smart contracts on the Ethereum blockchain. With this practical book, software developers with a high-level understanding of the blockchain will use the Solidity programming language to write decentralized applications (dApps) using the web3.js library.
Smart contracts have allowed technologists to create a new breed of software systems that have ushered in the next revolution in human organization. Kevin Solorio, Randall Kanna, and David Hoover teach you the fundamentals of Solidity, as well as key topics such as unit testing, deployment, and preventing security vulnerabilities. You'll also learn how to leverage the built-in public/private key cryptography in the Ethereum protocol.
Learn the fundamentals of how the Ethereum blockchain works
Setup a local Ethereum client using Parity
Develop and test secure smart contracts using Solidity and Vyper
Learn how to deploy smart contracts
Interact with your smart contract using Web3 (JavaScript)
Work with hands-on examples and walkthroughs of common scenarios

Most applications today are distributed in some fashion. Monitoring the health and performance of these distributed architectures requires a new approach. Enter distributed tracing, a method of profiling and monitoring applications—especially those that use microservice architectures. There’s just one problem: distributed tracing can be hard. But it doesn’t have to be.
With this practical guide, you’ll learn what distributed tracing is and how to use it to understand the performance and operation of your software. Key players at LightStep walk you through instrumenting your code for tracing, collecting the data that your instrumentation produces, and turning it into useful, operational insights. If you want to start implementing distributed tracing, this book tells you what you need to know.
You’ll learn:
The pieces of a distributed tracing deployment: Instrumentation, data collection, and delivering value
Best practices for instrumentation (the methods for generating trace data from your service)
How to deal with or avoid overhead, costs, and sampling
How to work with spans (the building blocks of request-based distributed traces) and choose span characteristics that lead to valuable traces
Where distributed tracing is headed in the future

This is the Scala edition of Category Theory for Programmers by Bartosz Milewski. This book contains code snippets in both Haskell and Scala.

Database System Concepts by Silberschatz, Korth and Sudarshan is now in its 7th edition and is one of the cornerstone texts of database education. It presents the fundamental concepts of database management in an intuitive manner geared toward allowing students to begin working with databases as quickly as possible.
The text is designed for a first course in databases at the junior/senior undergraduate level or the first year graduate level. It also contains additional material that can be used as supplements or as introductory material for an advanced course. Because the authors present concepts as intuitive descriptions, a familiarity with basic data structures, computer organization, and a high-level programming language are the only prerequisites. Important theoretical results are covered, but formal proofs are omitted. In place of proofs, figures and examples are used to suggest why a result is true.

Microservices have become the backbone of the largest web companies in existence today, including Netflix, Amazon, and Google. These companies run large distributed systems that span multiple datacenters and geographic regions, and this usually involves distributed schedulers, service discovery, load balancing, traffic shaping, monitoring, and logging solutions.
This practical book provides several common design patterns for building a platform around microservices at scale. Developers, software architects, infrastructure engineers, and site reliability engineers will learn about schedulers, fault tolerant remote procedure calls, distributed tracing, traffic shaping, and the role of chaos engineering in building resilient systems. You’ll be able to design a platform that can power microservices that span multiple datacenters, regions, and provide a high degree of availability on public and hybrid clouds.
You’ll explore:
The landscape of internet scale services
Guiding principles, practices, and core infrastructure components for building and scaling services on top of SOA/microservice architecture
Practices, tools, and techniques for operating large-scale microservices and distributed systems on dynamic and elastic infrastructure
Patterns and techniques for making internet services highly available and reliable, including multi-geography architectures

Understand how to apply distributed tracing to microservices-based architectures
Key Features
A thorough conceptual introduction to distributed tracing
An exploration of the most important open standards in the space
A how-to guide for code instrumentation and operating a tracing infrastructure
Book Description
Mastering Distributed Tracing will equip you to operate and enhance your own tracing infrastructure. Through practical exercises and code examples, you will learn how end-to-end tracing can be used as a powerful application performance management and comprehension tool.
The rise of Internet-scale companies, like Google and Amazon, ushered in a new era of distributed systems operating on thousands of nodes across multiple data centers. Microservices increased that complexity, often exponentially. It is harder to debug these systems, track down failures, detect bottlenecks, or even simply understand what is going on. Distributed tracing focuses on solving these problems for complex distributed systems. Today, tracing standards have developed and we have much faster systems, making instrumentation less intrusive and data more valuable.
Yuri Shkuro, the creator of Jaeger, a popular open-source distributed tracing system, delivers end-to-end coverage of the field in Mastering Distributed Tracing. Review the history and theoretical foundations of tracing; solve the data gathering problem through code instrumentation, with open standards like OpenTracing, W3C Trace Context, and OpenCensus; and discuss the benefits and applications of a distributed tracing infrastructure for understanding, and profiling, complex systems.
What you will learn
How to get started with using a distributed tracing system
How to get the most value out of end-to-end tracing
Learn about open standards in the space
Learn about code instrumentation and operating a tracing infrastructure
Learn where distributed tracing fits into microservices as a core function
Who this book is for
Any developer interested in testing large systems will find this book very revealing and in places, surprising. Every microservice architect and developer should have an insight into distributed tracing, and the book will help them on their way. System administrators with some development skills will also benefit. No particular programming language skills are required, although an ability to read Java, while non-essential, will help with the core chapters.