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

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

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

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

本书以图配文的形式，详细讲解了6种最重要的密码技术：对称密码、公钥密码、单向散列函数、消息认证码、数字签名和伪随机数生成器。
第1部分讲述了密码技术的历史沿革、对称密码、分组密码模式（包括ECB、CBC、CFB、OFB、CTR）、公钥、混合密码系统。第2部分重点介绍了认证方面的内容，涉及单向散列函数、消息认证码、数字签名、证书等。第3部分讲述了密钥、随机数、PGP、SSL/TLS 以及密码技术在现实生活中的应用。

原版连续畅销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语言基础的读者作为入门多线程编程之用，也适合有一定多线程编程经验的读者作为重新梳理知识结构以提升认知层次和参考之用。

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.

I am writing this book because I had a hard time learning Haskell.
It doesn't have to be that way. I've spent the last couple years actively teaching Haskell online and in person. Along the way, I started keeping notes on exercises and methods of teaching specific concepts and techniques in Haskell that eventually turned into my guide for learning haskell. That experience led me to work on this book.
If you are new to programming entirely, Haskell is a great first language. You may have noticed the trend of "Functional Programming in [Imperative Language]" books and tutorials and learning Haskell gets right to the heart of what functional programming is. Languages such as Java are gradually adopting functional concepts, but most such languages were not designed to be functional languages, after all. We would not encourage you to learn Haskell as an only language, but because Haskell is a pure functional language, it is a fertile environment for mastering functional programming techniques. That way of thinking and problem solving is useful, no matter what other languages you might know or learn.
Haskell is not a difficult language to use. Quite the opposite. I'm now able to tackle problems that I couldn't have tackled when I was primarily a Clojure, Common Lisp, or Python user. Haskell is difficult to teach effectively.

In this title: together we'll journey together through bits of cognitive and neuroscience, learning and behavioral theory; you'll discover some surprising aspects of how our brains work; and, see how you can beat the system to improve your own learning and thinking skills. In this book you'll learn how to: use the Dreyfus Model of Skill Acquisition to become more expert; leverage the architecture of the brain to strengthen different thinking modes; avoid common 'known bugs' in your mind; learn more deliberately and more effectively; and, manage knowledge more efficiently. Software development happens in your head. Not in an editor, IDE, or design tool. It's time to take a pragmatic approach to thinking and learning, and start to refactor - and redesign - your brain.

We're losing tens of billions of dollars a year on broken software, and great new ideas such as agile development and Scrum don't always pay off. But there's hope. The nine software development practices in Beyond Legacy Code are designed to solve the problems facing our industry. Discover why these practices work, not just how they work, and dramatically increase the quality and maintainability of any software project.
These nine practices could save the software industry. Beyond Legacy Code is filled with practical, hands-on advice and a common-sense exploration of why technical practices such as refactoring and test-first development are critical to building maintainable software. Discover how to avoid the pitfalls teams encounter when adopting these practices, and how to dramatically reduce the risk associated with building software--realizing significant savings in both the short and long term. With a deeper understanding of the principles behind the practices, you'll build software that's easier and less costly to maintain and extend.
By adopting these nine key technical practices, you'll learn to say what, why, and for whom before how; build in small batches; integrate continuously; collaborate; create CLEAN code; write the test first; specify behaviors with tests; implement the design last; and refactor legacy code.
Software developers will find hands-on, pragmatic advice for writing higher quality, more maintainable, and bug-free code. Managers, customers, and product owners will gain deeper insight into vital processes. By moving beyond the old-fashioned procedural thinking of the Industrial Revolution, and working together to embrace standards and practices that will advance software development, we can turn the legacy code crisis into a true Information Revolution.

Most security professionals don't have the words "security" or "hacker" in their job title. Instead, as a developer or admin you often have to fit in security alongside your official responsibilities - building and maintaining computer systems. Implement the basics of good security now, and you'll have a solid foundation if you bring in a dedicated security staff later. Identify the weaknesses in your system, and defend against the attacks most likely to compromise your organization, without needing to become a trained security professional.
Computer security is a complex issue. But you don't have to be an expert in all the esoteric details to prevent many common attacks. Attackers are opportunistic and won't use a complex attack when a simple one will do. You can get a lot of benefit without too much complexity, by putting systems and processes in place that ensure you aren't making the obvious mistakes. Secure your systems better, with simple (though not always easy) practices.
Plan to patch often to improve your security posture. Identify the most common software vulnerabilities, so you can avoid them when writing software. Discover cryptography - how it works, how easy it is to get wrong, and how to get it right. Configure your Windows computers securely. Defend your organization against phishing attacks with training and technical defenses.
Make simple changes to harden your system against attackers.