Is microservice architecture right for your organization? Microservices have many benefits, but they also come with their own set of drawbacks. With this updated edition, Java developers and architects will learn how to navigate popular application frameworks such Spring Boot and MicroProfile to deploy and manage microservices at scale with Linux containers. This hands-on, example-driven guide provides step-by-step instructions to help you get started.
Adopting microservices requires much more than changes to your technology. Author Rafael Benevides, director of developer experience at Red Hat, also examines the organizational agility necessary to deliver these services. This concise ebook shows you how rapid feedback cycles, autonomous teams, and shared purpose are key to making microservices work.
Learn why microservices require you to think differently about building, deploying, and operating cloud-native applications
Design microservices using the popular Spring Boot and Eclipse MicroProfile frameworks
Build an API gateway with Apache Camel to help clients access microservices
Use Docker and Kubernetes to deploy microservices, regardless of language
Run microservices at scale using cluster management, failover, and load-balancing techniques
Use OpenTracing to monitor requests, response time, and the path of particular invocations

Serverless Architectures on AWS, Second Edition teaches you how to design, secure, and manage serverless backend APIs for web and mobile applications on the AWS platform. You'll get going quickly with this book's relevant real-world examples, code listings, diagrams, and clearly-described architectures that you can readily apply to your own work. You’ll master serverless systems using AWS Lambda and the myriad of other services on the AWS platform.
This new edition has been fully updated to reflect the newest serverless design best practices and changes to AWS, including covering DynamoDB, Cognito, Google Firestore, AWS Elementals MediaConvert, Step Functions, and much more. There are also three new chapters dedicated to black belt tricks for Lambda, using patterns, and even DevOps for serverless applications.
what's inside
First steps with serverless computing
The principles of serverless design
Transitioning from servers to services
Important patterns and architectures
Writing AWS Lambda functions and using the API Gateway
Securing, deploying, and managing your finished architecture

Summary
Testing Java Microservices teaches you to implement unit and integration tests for microservice systems running on the JVM. You'll work with a microservice environment built using Java EE, WildFly Swarm, and Docker. You'll learn how to increase your test coverage and productivity, and gain confidence that your system will work as you expect.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.
About the Technology
Microservice applications present special testing challenges. Even simple services need to handle unpredictable loads, and distributed message-based designs pose unique security and performance concerns. These challenges increase when you throw in asynchronous communication and containers.
About the Book
Testing Java Microservices teaches you to implement unit and integration tests for microservice systems running on the JVM. You'll work with a microservice environment built using Java EE, WildFly Swarm, and Docker. You'll advance from writing simple unit tests for individual services to more-advanced practices like chaos or integration tests. As you move towards a continuous-delivery pipeline, you'll also master live system testing using technologies like the Arquillian, Wiremock, and Mockito frameworks, along with techniques like contract testing and over-the-wire service virtualization. Master these microservice-specific practices and tools and you'll greatly increase your test coverage and productivity, and gain confidence that your system will work as you expect.
What's Inside
Test automation
Integration testing microservice systems
Testing container-centric systems
Service virtualization

Access the power of bare-metal systems programming with Scala Native, an ahead-of-time Scala compiler. Without the baggage of legacy frameworks and virtual machines, Scala Native lets you re-imagine how your programs interact with your operating system. Compile Scala code down to native machine instructions; seamlessly invoke operating system APIs for low-level networking and IO; control pointers, arrays, and other memory management techniques for extreme performance; and enjoy instant start-up times. Skip the JVM and improve your code performance by getting close to the metal.
Developers generally build systems on top of the work of those who came before, accumulating layer upon layer of abstraction. Scala Native provides a rare opportunity to remove layers. Without the JVM, Scala Native uses POSIX and ANSI C APIs to build concise, expressive programs that run unusually close to bare metal. Scala Native compiles Scala code down to native machine instructions instead of JVM bytecode. It starts up fast, without the sluggish warm-up phase that's common for just-in-time compilers. Scala Native programs can seamlessly invoke operating system APIs for low-level networking and IO. And Scala Native lets you control pointers, arrays, and other memory layout types for extreme performance.
Write practical, bare-metal code with Scala Native, step by step. Understand the foundations of systems programming, including pointers, arrays, strings, and memory management. Use the UNIX socket API to write network client and server programs without the sort of frameworks higher-level languages rely on. Put all the pieces together to design and implement a modern, asynchronous microservice-style HTTP framework from scratch.
Take advantage of Scala Native's clean, modern syntax to write lean, high-performance code without the JVM.

Languages may come and go, but the relational database endures. Learn how to use Ecto, the premier database library for Elixir, to connect your Elixir and Phoenix apps to databases. Get a firm handle on Ecto fundamentals with a module-by-module tour of the critical parts of Ecto. Then move on to more advanced topics and advice on best practices with a series of recipes that provide clear, step-by-step instructions on scenarios commonly encountered by app developers. Co-authored by the creator of Ecto, this title provides all the essentials you need to use Ecto effectively.
Elixir and Phoenix are taking the application development world by storm, and Ecto, the database library that ships with Phoenix, is going right along with them. There are plenty of examples that show you the basics, but to use Ecto to its full potential, you need to learn the library from the ground up.
This definitive guide starts with a tour of the core features of Ecto - repos, queries, schemas, changesets, transactions - gradually building your knowledge with tasks of ever-increasing complexity. Along the way, you'll be learning by doing - a sample application handles all the boilerplate so you can focus on getting Ecto into your fingers.
Build on that core knowledge with a series of recipes featuring more advanced topics. Change your pooling strategy to maximize your database's efficiency. Use nested associations to handle complex table relationships. Add streams to handle large result sets with ease. Based on questions from Ecto users, these recipes cover the most common situations developers run into.
Whether you're new to Ecto, or already have an app in production, this title will give you a deeper understanding of how Ecto works, and help make your database code cleaner and more efficient.
What You Need:
To follow along with the book, you should have Erlang/OTP 19+ and Elixir 1.4+ installed. The book will guide you through setting up a sample application that integrates Ecto.

Programmers don't just use Kotlin, they love it. Even Google has adopted it as a first-class language for Android development. With Kotlin, you can intermix imperative, functional, and object-oriented styles of programming and benefit from the approach that's most suitable for the problem at hand. Learn to use the many features of this highly concise, fluent, elegant, and expressive statically typed language with easy-to-understand examples. Learn to write easy-to-maintain, high-performing JVM and Android applications, create DSLs, program asynchrony, and much more.
Kotlin is a highly concise, elegant, fluent, and expressive statically typed multi-paradigm language. It is one of the few languages that compiles down to both Java bytecode and JavaScript. You can use it to build server-side, front-end, and Android applications. With Kotlin, you need less code to accomplish your tasks, while keeping the code type-safe and less prone to error. If you want to learn the essentials of Kotlin, from the fundamentals to more advanced concepts, you've picked the right book.
Fire up your favorite IDE and practice hundreds of examples and exercises to sharpen your Kotlin skills. Learn to build standalone small programs to run as scripts, create type safe code, and then carry that knowledge forward to create fully object-oriented and functional style code that's easier to extend. Learn how to program with elegance but without compromising efficiency or performance, and how to use metaprogramming to build highly expressive code and create internal DSLs that exploit the fluency of the language. Explore coroutines, program asynchrony, run automated tests, and intermix Kotlin with Java in your enterprise applications.
This book will help you master one of the few languages that you can use for the entire full stack - from the server to mobile devices - to create performant, concise, and easy to maintain applications.

You’ve learned everything there is to know about Kubernetes. Now it’s time to put that knowledge into practice. With this practical book, tech leads, DevOps engineers, developers, and architects will learn real-world best practices for putting Kubernetes into action with actual applications. You’ll understand how to build and deploy complete solutions in Kubernetes—everything from CI/CD to application design, deployments, and experiments. You’ll also learn how other companies have delivered solutions in Kubernetes.

Neural networks are getting smaller. Much smaller. The OK Google team, for example, has run machine learning models that are just 14 kilobytes in size—small enough to work on the digital signal processor in an Android phone. With this practical book, you’ll learn about TensorFlow Lite for Microcontrollers, a miniscule machine learning library that allows you to run machine learning algorithms on tiny hardware.
Authors Pete Warden and Daniel Situnayake explain how you can train models that are small enough to fit into any environment, including small embedded devices that can run for a year or more on a single coin cell battery. Ideal for software and hardware developers who want to build embedded devices using machine learning, this guide shows you how to create a TinyML project step-by-step. No machine learning or microcontroller experience is necessary.
Learn practical machine learning applications on embedded devices, including simple uses such as speech recognition and gesture detection
Train models such as speech, accelerometer, and image recognition, you can deploy on Arduino and other embedded platforms
Understand how to work with Arduino and ultralow-power microcontrollers
Use techniques for optimizing latency, energy usage, and model and binary size

Functional programming is more than just writing the same old code in Scala, Clojure, or Haskell. To grok FP—to really get it—you need to rewire your brain to see the world differently. We're here to help you flip the switch. Grokking Functional Programming teaches you first to break down problems in a new way so you can approach them from a FP mindset. Following carefully-selected examples with thorough, carefully-paced explanations, you'll immerse yourself in FP concept by concept. Along the way, exercises, checks for understanding, and even the occasional puzzler give you opportunities to think and practice what you're learning.
what's inside
Designing with functions instead of objects
Multiple learning approaches to help you grok each new concept
A practical programming-first teaching style
Programming with immutable collections
Writing concurrent programs with a functional style

Kafka in Action is a practical, hands-on guide to building Kafka-based data pipelines. Filled with real-world use cases and scenarios, this book probes Kafka's most common use cases, ranging from simple logging through managing streaming data systems for message routing, analytics, and more. Starting with an overview of Kafka's core concepts, you'll immediately learn how to set up and execute basic data movement tasks and how to record and consume streaming data. As you move through the examples in this book, you'll learn the skills you need to work in a Kafka focused team with the ability to handle both developer and admin based tasks. At the end of this book, you'll be more than ready to dig into even more advanced Kafka topics on your own, and happily able to use Kafka in your day-to-day workflow.
what's inside
Understanding Kafka's concepts
Implementing Kafka as a message queue
Setting up and executing basic ETL tasks
Recording and consuming streaming data
Working with Kafka producers and consumers from Java applications
Using Kafka as part of a large data project team
Performing Kafka developer and admin tasks

Autotools is the first book to offer programmers a tutorial-based guide to the GNU build system. The new and improved second edition of Autotools includes five new chapters on PkgConfig, unit testing with Autotest, internationalizing with GNU, the portability of gnulib, and using Autotools with Windows.
Autotools focuses on two projects: Jupiter, a simple "Hello, world!" program, and FLAIM, an existing, complex open source effort containing four separate but interdependent subprojects. Follow along as the author takes Jupiter's build system from a basic makefile to a full-fledged Autotools project, and then as he converts the FLAIM projects from complex hand-coded makefiles to the powerful and flexible GNU build system.
You'll learn how to:
Generate Autoconf configuration scripts to simplify the compilation process
Produce portable makefiles with Automake
Build cross-platform software libraries with Libtool
Write your own Autoconf macros
Leave the guesswork behind and master the Autotools build system with Autotools!

If you've asked someone the secret to writing efficient, well-written software, the answer that you've probably gotten is "learn assembly language programming." By learning assembly language programming, you learn how the machine really operates and that knowledge will help you write better high-level language code. A dirty little secret assembly language programmers rarely admit to, however, is that what you really need to learn is machine organization, not assembly language programming. Write Great Code Vol I, the first in a series from assembly language expert Randall Hyde, dives right into machine organization without the extra overhead of learning assembly language programming at the same time. And since Write Great Code Vol I concentrates on the machine organization, not assembly language, the reader will learn in greater depth those subjects that are language-independent and of concern to a high level language programmer. Write Great Code Vol I will help programmers make wiser choices with respect to programming statements and data types when writing software, no matter which language they use.

Computer programming is not abstract and programs run on a machine. Knowing how computers work and how programs run on them is essential to becoming a better programmer, and understanding underlying technologies can help you develop a sense of what can go wrong.
The Secret Life of Programs fills in the gaps in computer education by giving readers a look under the hood of programming, at the machine. Readers learn how software behaves when running on hardware; how programs manipulate data in memory; how computers process languages; and how web browsers work. They'll also learn how to write efficient programs, computer security basics, and real-world considerations to have in mind when writing code.

From Charles M. Kozierok, the creator of the highly regarded www.pcguide.com, comes The TCP/IP Guide. This completely up-to-date, encyclopedic reference on the TCP/IP protocol suite will appeal to newcomers and the seasoned professional alike. Kozierok details the core protocols that make TCP/IP internetworks function and the most important classic TCP/IP applications, integrating IPv6 coverage throughout. Over 350 illustrations and hundreds of tables help to explain the finer points of this complex topic. The book抯 personal, user-friendly writing style lets readers of all levels understand the dozens of protocols and technologies that run the Internet, with full coverage of PPP, ARP, IP, IPv6, IP NAT, IPSec, Mobile IP, ICMP, RIP, BGP, TCP, UDP, DNS, DHCP, SNMP, FTP, SMTP, NNTP, HTTP, Telnet, and much more.
The TCP/IP Guide is a must-have addition to the libraries of internetworking students, educators, networking professionals, and those working toward certification.

C++ Crash Course cuts through the weeds to get you straight to the core of C++17, the most modern revision of the ISO standard. In Part I, you'll learn about all of the essential core language features. Part II introduces you to the C++ Standard Library and Boost Libraries, where you'll learn about high-quality, fully-featured facilities immediately available to you.
You'll learn all the major features of modern C++, including:
- Fundamental types, reference types, and user-defined types
- The object lifecycle including storage duration, memory management, exceptions, call stacks, and the RAII (resource acquisition is initialization) paradigm
- Compile-time polymorphism with templates and run-time polymorphism with virtual classes
- Advanced expressions, statements, and functions
- Smart pointers, data structures, dates and times, numerics, and probability/statistics facilities
- Containers, iterators, strings, and algorithms
- Streams and files, concurrency, networking, and application development

Great software comes from great designers. Learn the essential software architecture fundamentals every programmer needs to know. With hands-on examples in every chapter, tips and advice from respected architects, practical scenarios, and dozens of architectural design activities, Design It! shows you how to lead your team as a software architect to create excellent software.
Uncover the big ideas behind software architecture and learn practical methods for designing software systems big and small. Gain a framework for thinking about design, enabling you to plan, lead, design, implement, and evaluate software architectures. Collaborate with your team, stakeholders, and other architects. Dig for architecturally significant requirements and write detailed quality attribute scenarios. Explore design alternatives, balance trade-offs, manage risks, and choose technologies based on their architectural impact. Make the architecture real for everyone with powerful sketches, engaging stories, and lean documentation people love to read. Evaluate your designs using lightweight methods and harness the power of your team to improve the architecture over time. Host collaborative workshops that create buy-in and get the whole team excited and involved in designing the software architecture.
Hands-on exercises, real-world scenarios, and practical team-based decision-making tools will give you the experience you need to become a confident software architect.

Design and build scalable web applications quickly
This is an invaluable roadmap for meeting the rapid demand to deliver scalable applications in a startup environment. With a focus on core concepts and best practices rather than on individual languages, platforms, or technologies, Web Scalability for Startup Engineers describes how infrastructure and software architecture work together to support a scalable environment.
You’ll learn, step by step, how scalable systems work and how to solve common challenges. Helpful diagrams are included throughout, and real-world examples illustrate the concepts presented. Even if you have limited time and resources, you can successfully develop and deliver robust, scalable web applications with help from this practical guide.
Learn the key principles of good software design required for scalable systems Build the front-end layer to sustain the highest levels of concurrency and request rates Design and develop web services, including REST-ful APIs Enable a horizontally scalable data layer Implement caching best practices Leverage asynchronous processing, messaging, and event-driven architecture Structure, index, and store data for optimized search Explore other aspects of scalability, such as automation, project management, and agile teams

The foundation of all object-oriented software design, including agile methods such as extreme programming, is object thinking. But many developers have not mastered its underlying concepts and principles—relying on methodology and process instead of fully exploiting the power of object thinking in software design. In this essential, high-level reference, well-known object technologist David West provides a deep historical and contextual discussion of object thinking, including the behavioral approaches to object discovery and design. Readers will master the fundamental principles and learn how to apply object thinking to improve software development at every phase of the process.

Reddit hails itself as "the front page of the Internet." It's the third most-visited website in the United States--and yet, millions of Americans have no idea what it is.
We Are the Nerds is an engrossing look deep inside this captivating, maddening enterprise, whose army of obsessed users have been credited with everything from solving cold case crimes and spurring tens of millions of dollars in charitable donations to seeding alt-right fury and landing Donald Trump in the White House. We Are the Nerds is a gripping start-up narrative: the story of how Reddit's founders, Steve Huffman and Alexis Ohanian, rose up from their suburban childhoods to become millionaires and create an icon of the digital age--before seeing the site engulfed in controversies and nearly losing control of it for good.
Based on Christine Lagorio-Chafkin's exclusive access to founders Ohanian and Huffman, We Are the Nerds is also a compelling exploration of the way we all communicate today--and how we got here. Reddit and its users have become a mirror of the Internet: it has dingy corners, shiny memes, malicious trolls, and a sometimes heart-melting ability to connect people across cultures, oceans, and ideological divides.