Tackling the questions that systems designers care about, this book brings queueing theory decisively back to computer science. The book is written with computer scientists and engineers in mind and is full of examples from computer systems, as well as manufacturing and operations research. Fun and readable, the book is highly approachable, even for undergraduates, while still being thoroughly rigorous and also covering a much wider span of topics than many queueing books. Readers benefit from a lively mix of motivation and intuition, with illustrations, examples and more than 300 exercises - all while acquiring the skills needed to model, analyze and design large-scale systems with good performance and low cost. The exercises are an important feature, teaching research-level counterintuitive lessons in the design of computer systems. The goal is to train readers not only to customize existing analyses but also to invent their own.

MVC and CRUD make software easier to write, but harder to change. Microservice-based architectures can help even the smallest of projects remain agile in the long term, but most tutorials meander in theory or completely miss the point of what it means to be microservice-based. Roll up your sleeves with real projects and learn the most important concepts of evented architectures. You'll have your own deployable, testable project and a direction for where to go next.
Much ink has been spilled on the topic of microservices, but all of this writing fails to accurately identity what makes a system a monolith, define what microservices are, or give complete, practical examples, so you're probably left thinking they have nothing to offer you. You don't have to be at Google or Facebook scale to benefit from a microservice-based architecture. Microservices will keep even small and medium teams productive by keeping the pieces of your system focused and decoupled.
Discover the basics of message-based architectures, render the same state in different shapes to fit the task at hand, and learn what it is that makes something a monolith (it has nothing to do with how many machines you deploy to). Conserve resources by performing background jobs with microservices. Deploy specialized microservices for registration, authentication, payment processing, e-mail, and more. Tune your services by defining appropriate service boundaries. Deploy your services effectively for continuous integration. Master debugging techniques that work across different services. You'll finish with a deployable system and skills you can apply to your current project.
Add the responsiveness and flexibility of microservices to your project, no matter what the size or complexity.
What You Need:
While the principles of this book transcend programming language, the code examples are in Node.js because JavaScript, for better or worse, is widely read. You'll use PostgreSQL for data storage, so familiarity with it is a plus. The books does provide Docker images to make working with PostgreSQL a bit easier, but extensive Docker knowledge is not required.

Learn Kubernetes in a Month of Lunches is a task-focused guide to getting up and running with Kubernetes—fast! Following a proven and popular teaching approach honed by author Elton Stoneman, you'll progress quickly from the basics to production deployment. Each lesson is focused on practical ways to apply Kubernetes, including portable apps that work anywhere Kubernetes runs and how to run different architectures on a single cluster. All patterns are easy to apply to your own projects whatever your background. Sample apps demonstrate Kubernetes for .NET, Java, Go, or Node.JS, on varied architectures including small and large applications, monoliths and microservices, and both stateful and stateless components. By the time you’re done, you’ll be able to use Kubernetes as the platform for multiple application types, from legacy apps to serverless functions.
what's inside
Deploying and manage applications on Kubernetes clusters
Defining applications in Kubernetes YAML format
Kubernetes app lifecycle, from packaging to rollbacks
Self-healing and scalable apps
Securing a Kubernetes cluster
Using Kubernetes as a platform for new technologies
Exercises introducing all new concepts

Understand the language and vocabulary of Data Architecture.
The Data Architecture field is rife with terms that have become "fashionable". Some of the terms began with very specific, specialized, meanings - but as their use spread, they lost the precision of their technical definitions and become, well, "buzzwords".
A buzzword is "a word or expression from a particular subject area that has become fashionable because it has been used a lot". Compliance is "the obeying of an accepted principle or instruction that states the way things are or should be done." The assignment is to take buzzwords and follow rules to use them correctly. We cut through the hype to arrive at buzzword compliance - the state where you fully understand the words that in fact have real meaning in the data architecture industry. This book will rationalize the various ways all these terms are defined.
Of necessity, the book must address all aspects of describing an enterprise and its data management technologies. This includes a wide range of subjects, from entity/relationship modeling, through the semantic web, to database issues like relational and "beyond relational" ("NoSQL") approaches. In each case, the definitions for the subject are meant to be detailed enough to make it possible to understand basic principles - while recognizing that a full understanding will require consulting the sources where they are more completely described.
The book's Glossary contains a catalogue of definitions and its Bibliography contains a comprehensive set of references.

Getting Started with Kubernetes: With examples in Google Kubernetes Engine is a hands-on guide to taking your first steps into Kubernetes using the powerful Google Kubernetes Engine service. It lays out a map for taking an application, containerizing it, and then deploying it onto Kubernetes. You’ll learn best practice techniques for a stable and long-term Kubernetes deployment, including scaling and capacity planning, saving money by optimizing resource consumption, and tricks to make your day-to-day monitoring easier such as debugging code in the cloud. Kubernetes is the future of app development, so make sure you’re ahead of the curve —get started with Kubernetes today!
what's inside
Benefits of switching to Kubernetes
Containerize a web application with Docker
Host a containerized app on Kubernetes with a public cloud service
Save money and improve performance with cloud native technologies
Make your deployments reliable and fault tolerant without constant monitoring and intervention
Prepare your deployments to scale without a redesign
Monitor, debug and tune application deployments on Kubernetes in the cloud

If you’re training a machine learning model but aren’t sure how to put it into production, this book will get you there. Kubeflow provides a collection of cloud native tools for different stages of a model’s lifecycle, from data exploration, feature preparation, and model training to model serving. This guide helps data scientists build production-grade machine learning implementations with Kubeflow and shows data engineers how to make models scalable and reliable.
Using examples throughout the book, authors Holden Karau, Trevor Grant, Ilan Filonenko, Richard Liu, and Boris Lublinsky explain how to use Kubeflow to train and serve your machine learning models on top of Kubernetes in the cloud or in a development environment on-premises.
Understand Kubeflow’s design, core components, and the problems it solves
Learn how to set up Kubeflow on a cloud provider or on an in-house cluster
Train models using Kubeflow with popular tools including scikit-learn, TensorFlow, and Apache Spark
Learn how to add custom stages such as serving and prediction
Keep your model up-to-date with Kubeflow Pipelines
Understand how to validate machine learning pipelines

In Chaos Engineering: Crash test your applications you’ll learn to design and execute controlled failure experiments that reveal the hidden problems in your software. Using a toolbox of open source tools, you’ll inject system-shaking failures at every level—from your Docker containers, to your Kubernetes deployment, to the UI. You’ll learn Linux monitoring for observing system metrics and evaluating your results, and even how to apply Chaos Engineering to make your human teams more reliable and resilient to handling failures. Best of all, all tools and examples come with a downloadable Linux VM image, letting you easily experiment without risk to your own systems.
what's inside
Design, run and analyze Chaos Engineering experiments
See how applications react to a database connections latency
Experiment with Docker container isolation
Test software running on Kubernetes and the platform itself
Inject failure into software running in the HVM

With over 75 million downloads per month, Spring Boot is the most widely used Java framework available. Its ease and power have revolutionized application development from monoliths to microservices. Yet Spring Boot’s simplicity can also be confusing. How do developers learn enough to be productive immediately? This practical book shows you how to use this framework to write successful mission-critical applications.
Mark Heckler from VMware, the company behind Spring, guides you through Spring Boot’s architecture and approach, along with topics such as debugging, testing, and deployment. If you want to develop cloud native Java or Kotlin applications with Spring Boot rapidly and effectively—using reactive programming, building APIs, and creating database access of all kinds—this book is for you.
Learn how Spring Boot simplifies cloud native application development and deployment
Build reactive applications and extend communication across the network boundary to create distributed systems
Understand how Spring Boot’s architecture and approach increases developer productivity and application portability
Deploy Spring Boot applications for production workloads rapidly and reliably
Monitor application and system health for optimal performance and reliability
Debug, test, and secure cloud-based applications painlessly

Updated with the latest Maven coordinates, Java programming features, and API changes, this book is your guide to solving problems in writing asynchronous and event-based programs
Key Features
Explore a variety of tools and techniques used to solve problems in implementing concurrency and parallelization
Learn about core operators in RxJava that enable you to express your code logic productively
Apply RxJava with Kotlin to create responsive Android apps with better user experience
Book Description
RxJava is not just a popular library for building asynchronous and event-based applications; it also enables you to create a cleaner and more readable code base. In this book, you'll cover the core fundamentals of reactive programming and learn how to design and implement reactive libraries and applications.
Learning RxJava will help you understand how reactive programming works and guide you in writing your first example in reactive code. You'll get to grips with the workings of Observable and Subscriber, and see how they are used in different contexts using real-world use cases. The book will also take you through multicasting and caching to help prevent redundant work with multiple Observers. You'll then learn how to create your own RxJava operators by reusing reactive logic. As you advance, you'll explore effective tools and libraries to test and debug RxJava code. Finally, you'll delve into RxAndroid extensions and use Kotlin features to streamline your Android apps.
By the end of this book, you'll become proficient in writing reactive code in Java and Kotlin to build concurrent applications, including Android applications.
What you will learn
Discover different ways to create Observables, Observers, and Subscribers
Multicast in order to push data to multiple destinations and cache and replay them
Express RxJava idiomatically with the help of Kotlin features such as extension functions and data classes
Become familiar with various operators available in RxJava to perform common transformations and tasks
Explore RxJava's reactive types, including Flowable, Single, Maybe, and Completable
Demystify Observables and how they express data and events as sequences
Who this book is for
This book is for Java developers who want to leverage reactive programming to develop more resilient and concurrent applications. If you're an RxJava user looking to get to grips with the latest features and updates in RxJava 3, this book is for you. Fundamental knowledge of core Java features and object-oriented programming will assist you in understanding the key concepts covered in this book.

The AWS Certified Developer Associate certification demonstrates your expertise in developing, deploying, and maintaining applications on the world’s leading cloud platform, Amazon Web Services. AWS Certified Developer Associate Cert Guide is the comprehensive self-study resource for the updated version of Amazon’s valuable new exam.
Designed for all AWS Certified Developer Associate candidates, this guide covers every exam objective concisely and logically, with extensive teaching features designed to promote retention and understanding. You’ll find:
Hands-on labs you can perform with a free AWS account
Real-world examples throughout
Pre-chapter quizzes to assess knowledge upfront, and efficiently focus your study
Foundation topics sections that explain concepts and configurations, and link theory to practice
Key topics sections calling attention to every figure, table, and list you must know
Exam Preparation sections with additional chapter review features
Final preparation chapter with tools and resources to help you craft review and test-taking strategies and optimize study time
A customizable practice test library
This guide’s comprehensive, developer-focused, real-world coverage addresses all exam topics related to:
AWS authentication, identity and access management
Computing services
Data storage, processing, and transformation
AWS developer tools
DevOps: CI/CD in the cloud
AWS Cloud9 and CodeStar
Migrating, refactoring, monitoring, and troubleshooting AWS code

More than half of the analytics and machine learning (ML) models created by organizations today never make it into production. Instead, many of these ML models do nothing more than provide static insights in a slideshow. If they aren’t truly operational, these models can’t possibly do what you’ve trained them to do.
This report introduces practical concepts to help data scientists and application engineers operationalize ML models to drive real business change. Through lessons based on numerous projects around the world, six experts in data analytics provide an applied four-step approach—Build, Manage, Deploy and Integrate, and Monitor—for creating ML-infused applications within your organization.
You’ll learn how to:
Fulfill data science value by reducing friction throughout ML pipelines and workflows
Constantly refine ML models through retraining, periodic tuning, and even complete remodeling to ensure long-term accuracy
Design the ML Ops lifecycle to ensure that people-facing models are unbiased, fair, and explainable
Operationalize ML models not only for pipeline deployment but also for external business systems that are more complex and less standardized
Put the four-step Build, Manage, Deploy and Integrate, and Monitor approach into action

Companies working to become data driven often view data scientists as heroes, but that overlooks the vital role that data engineers play in the process. While data scientists focus on finding new insights from datasets, data engineers deal with preparation—obtaining, cleaning, and creating enhanced versions of the data an organization needs. In this report, Andy Oram examines how the role of data engineer has quickly evolved.
DBAs, software engineers, developers, and students will explore the responsibilities of modern data engineers and the skills and tools necessary to do the job. You’ll learn how to deal with software engineering concepts such as rapid and continuous development, automation and orchestration, modularity, and traceability. Decision makers considering a move to the cloud will also benefit from the in-depth discussion this report provides.
This report covers:
Major tasks of data engineers today
The different levels of structure in data and ways to maximize its value
Capabilities of third-party cloud options
Tools for ingestion, transfer, and enrichment
Using containers and VMs to run the tools
Software engineering development
Automation and orchestration of data engineering

Many people think leadership is a higher calling that exclusively resides in managers who practice or follow complex and compelling leadership philosophies. But what’s critical for leadership is principled consistency, because small things done well build and respect within the team.Using stories from his time as a senior leader at Slack, Pinterest, and Apple, Michael presents a series of leadership practices that help you build leadership skills. You’ll learn how to develop teams that are highly productive, highly respected, and highly trusted.
Using stories from his time as a senior leader at Slack, Pinterest, and Apple, Michael presents a series of leadership practices that help you build leadership skills. You’ll learn how to develop teams that are highly productive, highly respected, and highly trusted.
In this practical book, Michael illustrates the leadership skills he learned from exceptional leaders at three dynamic companies:
Act I: As a manager under James Barksdale at Netscape
Act II: As a senior manager/director under Steve Jobs at Apple
Act III: As an executive with Stewart Butterfield at Slack

本书通过具体的Java 程序，以浅显易懂的语言逐一说明了多线程和并发处理中常用的12 种设计模式。内容涉及线程的基础知识、线程的启动与终止、线程间的互斥处理与协作、线程的有效应用、线程的数量管理以及性能优化的注意事项等。此外，还介绍了一些多线程编程时容易出现的失误，以及多线程程序的阅读技巧等。在讲解过程中，不仅以图配文，理论结合实例，而且提供了运用模式解决具体问题的练习题和答案，帮助读者加深对多线程和并发处理的理解，并掌握其使用技巧。

原版连续畅销12年、重印25次！
194张图表 ＋ Java示例代码 = 轻松理解GoF的23种设计模式
《程序员的数学》《数学女孩》作者结城浩又一力作
◆图文并茂
194张图表（包括57张UML类图）穿插文中，帮助理解各设计模式
◆通俗易懂
用浅显的语言逐一讲解23种设计模式，读完此书会发现GoF书不再晦涩难懂
◆专业实用
编写了Java程序代码来实现设计模式，每章附带练习题和答案，用以熟练掌握设计 模式
◆拓展进阶
必要时对Java语言的功能进行了补充说明，可加深对Java的理解。此外，如果了解C++语言，同样可以轻松理解本书内容
本书适合以下读者阅读
•对面向对象开发感兴趣的人
•对设计模式感兴趣的人（特别是阅读了GoF书但是觉得难以理解的人）
•所有Java程序员（特别是对抽象类和接口的理解不充分的人）
本书以浅显易懂的语言逐一说明了GoF的23种设计模式。在讲解过程中，不仅搭配了丰富的图片，而且理论结合实例，用Java语言编写代码实现了设计模式的程序，让程序真正地运行起来，并提供了运用模式解决具体问题的练习题和答案。除此以外，本书在必要时还对Java语言的功能进行补充说明，以加深读者对Java的理解。

随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了——如今就连智能手机这样的消费类设备都已配备了4核乃至8核的处理器，更何况商用系统！在此背景下，以往靠单个处理器自身处理能力的提升所带来的软件计算性能提升的那种“免费午餐”已不复存在，这使得多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。故而，掌握多线程编程技能对广大开发人员的重要性亦由此可见一斑。《Java多线程编程实战指南（核心篇）》以基本概念、原理与方法为主线，辅以丰富的实战案例和生活化实例，并从Java虚拟机、操作系统和硬件多个层次与角度出发，循序渐进、系统地介绍Java平台下的多线程编程核心技术及相关工具。
《Java多线程编程实战指南（核心篇）》适合有一定Java语言基础的读者作为入门多线程编程之用，也适合有一定多线程编程经验的读者作为重新梳理知识结构以提升认知层次和参考之用。

随着 CPU 多核时代的到来，多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。解决多线程编程中频繁出现的普遍问题可以借鉴设计模式所提供的现成解决方案。然而，多线程编程相关的设计模式图书多采用C++作为描述语言，且书中所举的例子多与应用开发人员的实际工作 相去甚远。《Java多线程编程实战指南：设计模式篇（第2版）》采用Java 语言和UML 为描述语言，并结合作者多年工作经历及相关实践经验，介绍了多线程环境下常用设计模式的来龙去脉：各个设计模式是什么样的、典型的实际应用场景、实际应用时需要 注意的事项及各个设计模式的可复用实现代码。
《Java多线程编程实战指南：设计模式篇（第2版）》第2 版除更正了第1 版中的错误外，还新增了JDK 8、JDK 9 中与多线程设计模式相关的内容， 并对代码进行了重构和重新排版，使代码部分重点更突出、更易于阅读，以及提高了插图的清晰度。
《Java多线程编程实战指南：设计模式篇（第2版）》适合有一定Java 多线程编程基础、经验的读者阅读。

Building RESTful web services can be tough as there are countless standards and ways to develop API. In modern architectures such as microservices, RESTful APIs are common in communication, making idiomatic and scalable API development crucial. This book covers basic through to advanced API development concepts and supporting tools.
You'll start with an introduction to REST API development before moving on to building the essential blocks for working with Go. You'll explore routers, middleware, and available open source web development solutions in Go to create robust APIs, and understand the application and database layers to build RESTful web services. You'll learn various data formats like protocol buffers and JSON, and understand how to serve them over HTTP and gRPC. After covering advanced topics such as asynchronous API design and GraphQL for building scalable web services, you'll discover how microservices can benefit from REST. You'll also explore packaging artifacts in the form of containers and understand how to set up an ideal deployment ecosystem for web services. Finally, you'll cover the provisioning of infrastructure using infrastructure as code (IaC) and secure your REST API.
By the end of the book, you'll have intermediate knowledge of web service development and be able to apply the skills you've learned in a practical way.
What you will learn
Explore the fundamentals of API development and web services
Understand the various building blocks of API development in Go
Use superior open source solutions for representational state transfer (REST) API development
Scale a service using microservices and asynchronous design patterns
Deliver containerized artifacts to the Amazon Web Services (AWS) Cloud
Get to grips with API security and its implementation

The Tao of Microservices guides you on the path to understanding and building microservices. Based on the invaluable experience of microservices guru Richard Rodger, this book exposes the thinking behind microservice designs. You'll master individual concepts like asynchronous messaging, service APIs, and encapsulation as you learn to apply microservices architecture to real-world projects. Along the way, you'll dig deep into detailed case studies with source code and documentation and explore best practices for team development, planning for change, and tool choice.
what's inside
Principles of the microservice architecture
Breaking down real-world case studies
Implementing large-scale systems
When not to use microservices

Secure, monitor, and test your cloud-native applications using the Service Mesh architecture
Key Features
Manage your cloud-native applications with ease using the service mesh architecture
Learn about Istio, Linkerd, and Consul - the three primary open-source service mesh providers
Includes tips and best practices for building secure, high-performance microservices
Book Description
A microservices-based application helps DevOps and continuous delivery, but it adds the complexity of testing and observability. Implementation of a service mesh architecture allows you to secure, manage, and scale your microservices more efficiently. Through practical examples, this book shows you how to install, configure and deploy an efficient service mesh for microservices in a Kubernetes environment.
With this book, you will get a hands-on introduction to the concept of cloud-native application management and the service mesh architecture. It introduces you to three major service mesh providers, namely Istio, Linkerd, and Consul. You will explore their capabilities such as traffic management, monitoring, security, telemetry, certificate authority, sidecar injections, observability and many more.
By the end of this book, you will develop the necessary skills to manage modern microservices-based applications.
What you will learn
Learn Service Mesh control and data plane concepts
Learn about the service mesh architecture with hands-on examples
Compare Istio, Linkerd, and Consul
Differentiate capabilities for the three service mesh providers
Develop and manage your microservices applications with ease
Explore Service Mesh features like Traffic management, Service discovery, Resiliency and many more
Who This Book Is For
The book is for solution architects, network administrators, as well as DevOps and site reliability engineers who are new to the cloud native framework. This book will help the audience to pursue a lucrative career in DevOps and especially Operations. A high-level understanding of Kubernetes and cloud-native microservices knowledge is preferred to get the most out of this book.