试读本书、获取示例源码请访问本书读者服务网站： RedisGuide.com
本书系统化介绍Redis命令及其应用场景，内容深入，图文并茂，巨细靡遗，是掌握Redis的案头必备参考书。
本书主要分为三大部分，共20章。
第一部分“数据结构与应用”介绍Redis最核心的九种数据结构，列举了操作这些数据结构的众多命令及其详细信息，并在其中穿插介绍了多 个使用 Redis 命令构建应用序的示例。通过这些程序示例，读者可以进一步加深对命令的认识，并学会如何在实际中应用这些命令，从而达到学而致用的目的。
第二部分“附加功能”介绍Redis在数据结构的基础上为用户提供的额外功能。其中包括数据库管理、自动过期功能、流水线与事务、Lua 脚本、持久化、发布与订阅、模块管理等。读者可以通过阅读这一部分来学会如何将 Redis 应用在更多场景中。
第三部分“多机功能”介绍 Redis 的三项多机功能：复制、Sentinel 和集群。读者可以通过阅读这一部分来获得扩展 Redis 读写性能的相关知识，并根据自己的情况为 Redis 系统选择合适的扩展方式。

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.

See how Domain-Driven Design (DDD) combines with Jakarta EE MicroProfile or Spring Boot to offer a complete suite for building enterprise-grade applications. In this book you will see how these all come together in one of the most efficient ways to develop complex software.
Practical Domain-Driven Design in Enterprise Java starts by building out the Cargo Tracker reference application as a monolithic application using the Jakarta EE platform. By doing so, you will map concepts of DDD (bounded contexts, language, and aggregates) to the corresponding available tools (CDI, JAX-RS, and JPA) within the Jakarta EE platform.
Once you have completed the monolithic application, you will walk through the complete conversion of the monolith to a microservices-based architecture, again mapping the concepts of DDD and the corresponding available tools within the MicroProfile platform (config, discovery, and fault tolerance). To finish this section, you will examine the same microservices architecture on the Spring Boot platform.
The final set of chapters looks at what the application would be like if you used the CQRS and event sourcing patterns. Here you’ll use the Axon framework as the base framework.
You will:
Discover the DDD architectural principles and use the DDD design patterns
Use the new Eclipse Jakarta EE platform
Work with the Spring Boot framework
Implement microservices design patterns, including context mapping, logic design, entities, integration, testing, and security
Carry out event sourcing
Apply CQRS

This book covers elementary discrete mathematics for computer science and engineering. It emphasizes mathematical definitions and proofs as well as applicable methods. Topics include formal logic notation, proof methods; induction, well-ordering; sets, relations; elementary graph theory; integer congruences; asymptotic notation and growth of functions; permutations and combinations, counting principles; discrete probability. Further selected topics may also be covered, such as recursive definition and structural induction; state machines and invariants; recurrences; generating functions.

Designing APIs with Swagger and OpenAPI is a hands-on primer for describing, planning and designing web APIs. Core Swagger contributor Josh Ponelat introduces you to a design-first paradigm that will teach you the best practices for describing and designing RESTful APIs using OpenAPI and Swagger. You’ll build upon progressively-enhanced examples as you learn to describe an API and then extend it in the kind of scenarios you’d encounter in the real world. You’ll practice skills for assessing business needs, gathering requirements, and working with a cross-functional team. And as you go, you’ll use the popular Open Source tools to define APIs, generate documentation, and build other developer-friendly components like mocks, server stubs, and client SDKs.
what's inside
OpenAPI syntax and structure
Using Swagger and OSS tooling to create OpenAPI definitions
Automating processes and generating code
Working with cross-functional teams

While compilers for high-level programming languages are large complex software systems, they have particular characteristics that differentiate them from other software systems. Their functionality is almost completely well-defined – ideally there exist complete precise descriptions of the source and target languages, while additional descriptions of the interfaces to the operating system, programming system and programming environment, and to other compilers and libraries are often available. The implementation of application systems directly in machine language is both difficult and error-prone, leading to programs that become obsolete as quickly as the computers for which they were developed. With the development of higher-level machine-independent programming languages came the need to offer compilers that were able to translate programs into machine language. Given this basic challenge, the different subtasks of compilation have been the subject of intensive research since the 1950s.
This book is not intended to be a cookbook for compilers, instead the authors' presentation reflects the special characteristics of compiler design, especially the existence of precise specifications of the subtasks. They invest effort to understand these precisely and to provide adequate concepts for their systematic treatment. This is the first book in a multivolume set, and here the authors describe what a compiler does, i.e., what correspondence it establishes between a source and a target program. To achieve this the authors specify a suitable virtual machine (abstract machine) and exactly describe the compilation of programs of each source language into the language of the associated virtual machine for an imperative, functional, logic and object-oriented programming language.
This book is intended for students of computer science. Knowledge of at least one imperative programming language is assumed, while for the chapters on the translation of functional and logic programming languages it would be helpful to know a modern functional language and Prolog. The book is supported throughout with examples, exercises and program fragments.

This delightful book leads you through the basic elements of programming in Scheme (a Lisp dialect) via a series of dialogues with well-chosen questions and exercises. Besides teaching Scheme, The Little Schemer teaches the reader how to think about computation. The authors focus on ten essential concepts of thinking about how to compute and demonstrate how to apply these concepts in inventive ways. The Little Schemer is an excellent book both for the beginner and for the seasoned programmer.

[FROM www.amazon.com]:
The Little Prover introduces inductive proofs as a way to determine facts about computer programs. It is written in an approachable, engaging style of question-and-answer, with the characteristic humor of The Little Schemer (fourth edition, MIT Press). Sometimes the best way to learn something is to sit down and do it; the book takes readers through step-by-step examples showing how to write inductive proofs. The Little Prover assumes only knowledge of recursive programs and lists (as presented in the first three chapters of The Little Schemer) and uses only a few terms beyond what novice programmers already know. The book comes with a simple proof assistant to help readers work through the book and complete solutions to every example.

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

本书由Ruby 之父松本行弘在《日经Linux》杂志上的连载整合而成，主要介绍了新语言Streem 的设计与实现过程。作者从设计Streem 这门新语言的动机开始讲起，由浅入深，详细介绍了新语言开发中的各个环节，以及语言设计上的纠结与取舍，其中也不乏对其他编程语言的调查与思考，向读者展示了创建编程语言的乐趣。

In Grokking Simplicity, you’ll learn techniques and, more importantly, a mindset that will help you tackle common problems that arise when software gets complex. Veteran functional programmer Eric Normand guides you to a crystal-clear understanding of why certain features of modern software are so prone to complexity and introduces you to the functional techniques you can use to simplify these systems so that they’re easier to read, test, and debug. Through hands-on examples, exercises, and numerous self-assessments, you’ll learn to organize your code for maximum reusability and internalize methods to keep unwanted complexity out of your codebase. Regardless of the language you’re using, the ways of thinking in this book will help recognize problematic code and tame even the most complex software.
what's inside
Apply functional programming principles to reduce codebase complexity
Work with data transformation pipelines for code that’s easier to test and reuse
Tools for modeling time to simplify asynchrony
60 exercises and 100 questions to test your knowledge

An exhilarating, elegant memoir and a significant polemic on how computers and algorithms shape our understanding of the world and of who we are
Bitwise is a wondrous ode to the computer languages and codes that captured technologist David Auerbach’s imagination. With a philosopher’s sense of inquiry, Auerbach recounts his childhood spent drawing ferns with the programming language Logo on the Apple IIe, his adventures in early text-based video games, his education as an engineer, and his contributions to instant messaging technology developed for Microsoft and the servers powering Google’s data stores. A lifelong student of the systems that shape our lives—from the psychiatric taxonomy of the Diagnostic and Statistical Manual to how Facebook tracks and profiles its users—Auerbach reflects on how he has experienced the algorithms that taxonomize human speech, knowledge, and behavior and that compel us to do the same.
Into this exquisitely crafted, wide-ranging memoir of a life spent with code, Auerbach has woven an eye-opening and searing examination of the inescapable ways in which algorithms have both standardized and coarsened our lives. As we engineer ever more intricate technology to translate our experiences and narrow the gap that divides us from the machine, Auerbach argues, we willingly erase our nuances and our idiosyncrasies—precisely the things that make us human.

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