Vert.x in Action teaches you to build highly-scalable reactive enterprise applications. In this practical developer’s guide, Vert.x expert Julien Ponge gets you up to speed in the basics of asynchronous programming as you learn to design and code reactive applications. Using the Vert.x asynchronous APIs, you’ll build services including web stack, messaging, authentication, and access control. You’ll also dive into deployment of container-native components with Docker, Kubernetes, and OpenShift. Along the way, you’ll check your app’s health and learn to test its resilience to external service failures.
As a member of the Vert.x core team, Julien Ponge has up-close-and-personal experience you can trust. The lessons and examples in this book center on principles that will easily transfer to other reactive technologies, empowering you to apply what you learn using Vert.x or the reactive tech of your choice. With the rising tide of microservices and distributed systems, reactive programming is flowing into the mainstream. With Vert.x in Action, you’ll be sailing smoothly!
what's inside
An introduction to asynchronous programming and reactive systems
Building reactive services
Responding to external service failures
Horizontal scaling
Deploying with Docker, Kubernetes, and OpenShift

The Software Foundations series is a broad introduction to the mathematical underpinnings of reliable software.
The principal novelty of the series is that every detail is one hundred percent formalized and machine-checked: the entire text of each volume, including the exercises, is literally a "proof script" for the Coq proof assistant.
The exposition is intended for a broad range of readers, from advanced undergraduates to PhD students and researchers. No specific background in logic or programming languages is assumed, though a degree of mathematical maturity is helpful. A one-semester course can expect to cover Logical Foundations plus most of Programming Language Foundations or Verified Functional Algorithms, or selections from both.

Everything you really need to know in Machine Learning in a hundred pages.
This is the first of its kind "read first, buy later" book. You can find the book online, read it, and then come back to pay for it if you liked the book or found it useful for your work, business or studies.
Review
"This book provides a great practical guide to get started and execute on ML within a few days without necessarily knowing much about ML apriori. The first five chapters are enough to get you started and the next few chapters provide you a good feel of more advanced topics to pursue. A wonderful book for engineers who want to incorporate ML in their day-to-day work without necessarily spending an enormous amount of time going through a formal degree program."--Deepak Agarwal, VP of Artificial Intelligence at LinkedIn
"This book is a great introduction to machine learning from a world-class practitioner and LinkedIn superstar Andriy Burkov. He managed to find a good balance between the math of the algorithms, intuitive visualizations, and easy-to-read explanations. This book will benefit the newcomers to the field as a thorough introduction to the fundamentals of machine learning, while the experienced professionals will definitely enjoy the practical recommendations from Andriy's rich experience in the field."--Karolis Urbonas, Head of Data Science at Amazon
"I wish such a book existed when I was a statistics graduate student trying to learn about machine learning. There is the right amount of math which demystify the centerpiece of an algorithm with succinct but very clear descriptions. I'm also impressed by the widespread coverage and good choices of important methods as an introductory book (not all machine learning books mention things like learning to rank or metric learning). Highly recommended to STEM major students."--Chao Han, VP, Head of R&D at Lucidworks
"This book provides a great practical guide to get started and execute on ML within a few days without necessarily knowing much about ML apriori. The first five chapters are enough to get you started and the next few chapters provide you a good feel of more advanced topics to pursue. A wonderful book for engineers who want to incorporate ML in their day-to-day work without necessarily spending an enormous amount of time going through a formal degree program."--Sujeet Varakhedi, Head of Engineering at eBay
"The Hundred-Page Machine Learning Book is an excellent read to get started with Machine Learning. In his book, Andriy Burkov distills the ubiquitous material on Machine Learning into concise and well-balanced intuitive, theoretical and practical elements that bring beginners, managers, and practitioners many life hacks."--Vincent Pollet, Head of Research at Nuance

A practical guide and reference to developing multithreaded programs on UNIX systems written by the foremost experts on the technology. Covers the two main UNIX threads and the UNIX International threads standard. All examples in the book use the POSIX standard.

Written by three leading researchers in the field, this book provides in-depth coverage of the theory concerning the logical level of database management systems, including both classical and advanced topics. Features *Emphasizes query languages for the relational model including coverage of different language paradigms, expressive power, and complexity. *Presents a unified theory of dependencies, including those commonly arising in practice, and their use in optimization and schema design. *Provides theoretical underpinnings of several emerging topics, including deductive and object-oriented databases. *Includes detailed proofs and numerous examples and exercises. 0201537710B04062001

"Database Management Systems" provides comprehensive and up-to-date coverage of the fundamentals of database systems. Coherent explanations and practical examples have made this one of the leading texts in the field. The third edition continues in this tradition, enhancing it with more practical material. The new edition has been reorganized to allow more flexibility in the way the course is taught. Now, instructors can easily choose whether they would like to teach a course which emphasizes database application development or a course that emphasizes database systems issues. New overview chapters at the beginning of parts make it possible to skip other chapters in the part if you don't want the detail. More applications and examples have been added throughout the book, including SQL and Oracle examples. The applied flavor is further enhanced by the two new database applications chapters.

Linux now offers an exceptionally robust environment for driver development: with today's kernels, what once required years of development time can be accomplished in days. In this practical, example-driven book, one of the world's most experienced Linux driver developers systematically demonstrates how to develop reliable Linux drivers for virtually any device. Essential Linux Device Drivers is for any programmer with a working knowledge of operating systems and C, including programmers who have never written drivers before. Sreekrishnan Venkateswaran focuses on the essentials, bringing together all the concepts and techniques you need, while avoiding topics that only matter in highly specialized situations. Venkateswaran begins by reviewing the Linux 2.6 kernel capabilities that are most relevant to driver developers. He introduces simple device classes; then turns to serial buses such as I2C and SPI; external buses such as PCMCIA, PCI, and USB; video, audio, block, network, and wireless device drivers; user-space drivers; and drivers for embedded Linux–one of today's fastest growing areas of Linux development. For each, Venkateswaran explains the technology, inspects relevant kernel source files, and walks through developing a complete example.
• Addresses drivers discussed in no other book, including drivers for I2C, video, sound, PCMCIA, and different types of flash memory
• Demystifies essential kernel services and facilities, including kernel threads and helper interfaces
• Teaches polling, asynchronous notification, and I/O control
• Introduces the Inter-Integrated Circuit Protocol for embedded Linux drivers
• Covers multimedia device drivers using the Linux-Video subsystem and Linux-Audio framework
• Shows how Linux implements support for wireless technologies such as Bluetooth, Infrared, WiFi, and cellular networking
• Describes the entire driver development lifecycle, through debugging and maintenance
• Includes reference appendixes covering Linux assembly, BIOS calls, and Seq files

Eager to develop embedded systems? These systems don't tolerate inefficiency, so you may need a more disciplined approach to programming. This easy-to-read book helps you cultivate a host of good development practices, based on classic software design patterns as well as new patterns unique to embedded programming. You not only learn system architecture, but also specific techniques for dealing with system constraints and manufacturing requirements. Written by an expert who's created embedded systems ranging from urban surveillance and DNA scanners to children's toys, Making Embedded Systems is ideal for intermediate and experienced programmers, no matter what platform you use. * Develop an architecture that makes your software robust and maintainable * Understand how to make your code smaller, your processor seem faster, and your system use less power * Learn how to explore sensors, motors, communications, and other I/O devices * Explore tasks that are complicated on embedded systems, such as updating the software and using fixed point math to implement complex algorithms

Learn the essentials of real-time operating systems. Part I of this comprehensive and detailed book provides a thorough explanation of Micriμm's popular µC/OS-III real-time kernel. Part II describes practical, working applications for embedded medical devices built on µC/OS-III and Freescale's TWR-K53N512 medical board (ARM® Cortex™-M4) using Codewarrior and IAR development tools. Each of the included examples feature hands-on working projects, which allow you to get your application running quickly, and can serve as a reference design for implementing µC/OS-III.
This book is written for serious embedded systems programmers, consultants, hobbyists, and students interested in understanding the inner workings of a real-time kernel. μC/OS-III is more than just a great learning platform. It is a full commercial-grade software package, ready to serve as the foundation for a wide range of products.
μC/OS-III is a highly portable, ROMable, scalable, preemptive real-time, multitasking kernel designed specifically to address the demanding requirements of today's embedded systems. μC/OS-III is the successor to the highly popular μC/OS-II real-time kernel and can use most of μC/OS-II's ports with only minor modifications.
Some of the features of μC/OS-III are:
Preemptive multitasking with round-robin scheduling of tasks at the same priority.
Supports an unlimited number of tasks and other kernel objects.
Rich set of services: semaphores, mutual exclusion semaphores with full priority inheritance, event flags, message queues, timers, fixed-size memory block management, and more.
Built-in performance measurements.

A single dramatic software failure can cost a company millions of dollars—but can be avoided with simple changes to design and architecture. This new edition of the best-selling industry standard shows you how to create systems that run longer, with fewer failures, and recover better when bad things happen. New coverage includes DevOps, microservices, and cloud-native architecture. Stability antipatterns have grown to include systemic problems in large-scale systems. This is a must-have pragmatic guide to engineering for production systems.

The official book on the Rust programming language, written by the Rust development team at the Mozilla Foundation, fully updated for Rust 2018.
The Rust Programming Language is the official, definitive guide to Rust, a hugely popular, community-supported programming language. This is the second edition of the improved version of the free online Rust book, so well-loved in the Rust community that it is simply referred to as "the Book".
Programmers love Rust because it allows them to write powerful code efficiently, without the risk of crashes and errors common in languages like C and C++. This book will show readers how to use Rust's robust type system to keep programs memory-safe and speedy, and make the most of the Cargo package manager that brings the pieces of a program together. The reader will learn all about Rust's ownership rules, which lie at the heart of Rust's reliability and crash-resistant compiling.
The Rust Programming Language covers everything from basic concepts like variable bindings, control flow, functions, and error handling, to more advanced topics, such as crates, generics, concurrency, and the nitty gritty of Rust's type system. With improved organization, hands-on features, and a more tutorial-oriented style, this version offers a vast improvement over the original.
The second edition also provides an entirely new chapter on macros and an expanded chapter on crates, two key aspects of Rust that make it so popular. Readers will also find extra appendices on Rust development tools and Rust versions.

This book covers the breadth of Haskell's diverse selection of programming APIs for concurrent and parallel programming. It is split into two parts. The first part, on parallel programming, covers the techniques for using multiple processors to speed up CPU-intensive computations, including methods for using parallelism in both idiomatic Haskell and numerical array-based algorithms, and for running computations on a GPU. The second part, on concurrent programming, covers techniques for using multiple threads, including overlapping multiple I/O operations, building concurrent network servers, and distributed programming across multiple machines.

Transactions are a concept related to the logical database as seen from the perspective of database application programmers: a transaction is a sequence of database actions that is to be executed as an atomic unit of work. The processing of transactions on databases is a well- established area with many of its foundations having already been laid in the late 1970s and early 1980s.
The unique feature of this textbook is that it bridges the gap between the theory of transactions on the logical database and the implementation of the related actions on the underlying physical database. The authors relate the logical database, which is composed of a dynamically changing set of data items with unique keys, and the underlying physical database with a set of fixed-size data and index pages on disk. Their treatment of transaction processing builds on the “do-redo-undo” recovery paradigm, and all methods and algorithms presented are carefully designed to be compatible with this paradigm as well as with write-ahead logging, steal-and-no-force buffering, and fine-grained concurrency control.
Chapters 1 to 6 address the basics needed to fully appreciate transaction processing on a centralized database system within the context of our transaction model, covering topics like ACID properties, database integrity, buffering, rollbacks, isolation, and the interplay of logical locks and physical latches. Chapters 7 and 8 present advanced features including deadlock-free algorithms for reading, inserting and deleting tuples, while the remaining chapters cover additional advanced topics extending on the preceding foundational chapters, including multi-granular locking, bulk actions, versioning, distributed updates, and write-intensive transactions.
This book is primarily intended as a text for advanced undergraduate or graduate courses on database management in general or transaction processing in particular.

Erlang's process-oriented approach has given it a very different runtime environment. As Erlang and tools built on Erlang, like CouchDB, Riak, and EjabberD spread, understanding those underpinnings becomes much more important for people building and maintaining applications. This book will explore Erlang's unique approach to building a virtual machine, demonstrating how to take advantage of its power and tune it to fit your needs.

This book describes the key concepts, principles and implementation options for creating high-assurance cloud computing solutions. The guide starts with a broad technical overview and basic introduction to cloud computing, looking at the overall architecture of the cloud, client systems, the modern Internet and cloud computing data centers. It then delves into the core challenges of showing how reliability and fault-tolerance can be abstracted, how the resulting questions can be solved, and how the solutions can be leveraged to create a wide range of practical cloud applications. The author's style is practical, and the guide should be readily understandable without any special background. Concrete examples are often drawn from real-world settings to illustrate key insights. Appendices show how the most important reliability models can be formalized, describe the API of the Isis2 platform, and offer more than 80 problems at varying levels of difficulty.

Get Programming with Scala teaches you the core skills you'll need to code with Scala. This book lives up to its name! You'll learn the ins and outs of Scala by actually programming with it, thanks to the practical examples, exercises, and easy-to-follow lessons. You'll start by reviewing OOP concepts in the Scala language. Then, example-by-example, you'll gradually open up the world of functional programming. You'll explore functions and types and learn how to combine them to create powerful, flexible abstractions. Along the way, you'll learn some Scala testing and get an intuition for sniffing out and fixing code that doesn't smell quite right.
what's inside
Learn to express OO principles in Scala
Express your program designs in functions
Make use of types to enforce program requirements
Use abstractions to avoid code duplication
Write meaningful tests and recognize code smells

Written by Bina Ramamurthy, award-winning creator of the blockchain Coursera online course, Blockchain in Action begins with the essential principles of blockchain and teaches you to create your own decentralized apps. From the start you’ll go hands-on with the Ethereum blockchain, designing and coding your first smart contract with the JavaScript-based Solidity language. This smart contract will become the foundation on which you will build advanced functionality, including trust validation, a web UI for better user access, and privacy and security features that enable deployment on a public blockchain network. By the time you’re finished, you’ll be fully prepared to build useful blockchain applications.
what's inside
How blockchain differs from other distributed systems
Smart contract development with Ethereum and the Solidity language
Web UI for decentralized apps
Identity, privacy and security techniques
On-chain and off-chain data storage

Pulsar in Action is a hands-on guide to building scalable streaming messaging systems for distributed applications and microservices systems. You’ll start with Pulsar’s fundamentals, each illustrated by real-world examples, as you get to grips with Pulsar’s unique architecture. Pulsar contributor David Kjerrumgaard teaches the skills you need to deploy a Pulsar server, ingest data from third-party systems, and deploy lightweight computing logic with simple functions. You’ll learn to employ Pulsar’s seamless scalability through relatable case studies, including an IOT analytics application that can be deployed within a resource constrained environment and a microservices application based on Pulsar functions. At the end of this practical book, you’ll be ready to fully take advantage of Pulsar to create high-traffic message-driven applications.
what's inside
Publish from Apache Pulsar into third-party data repositories and platforms
Design and develop Apache Pulsar functions
Perform interactive SQL queries against data stored in Apache Pulsar
Examples of Pulsar-based microservices that you can download and try yourself

Synthesis Lectures on Distributed Computing Theory is edited by Michel Raynal of the University of Rennes, France and was founded by Nancy Lynch of the Massachusetts Institute of Technology. The series publishes 50- to 150-page publications on topics pertaining to distributed computing theory. The scope largely follows the purview of premier information and computer science conferences, such as ACM PODC, DISC, SPAA, OPODIS, CONCUR, DialM-POMC, ICDCS, SODA, Sirocco, SSS, and related conferences. Potential topics include, but not are limited to: distributed algorithms and lower bounds, algorithm design methods, formal modeling and verification of distributed algorithms, and concurrent data structures.

We've made a dent into the 21st century and software has been eating the world. Suspenseful tech dramas play out in the news, boot camps churn out entry-level developers in a matter of months, and there's even an HBO show dedicated to Silicon Valley.
In the midst of these trends lies a severe lack of attention to the daily life of the developer--the day-to-day reality that surrounds each line of code. There are plenty of resources available to help the budding developer learn how to code, but what about everything else?
Who Should Read This Book?
This book is for anyone interested in getting a sneak peek inside the world of software!
The new graduates about to jump into their first jobs
The veterans who want a dose of nostalgia and a good chuckle
The product managers looking to empathize more with their coding counterparts
The disgruntled developers contemplating the meaning of life
The high school students thinking about jumping on the computer science bandwagon
The budding programmers looking to become more effective and gain more leverage at work
What's Inside The Book?
This book is a highlight reel of content revolving around Software Developer Life.
Inside you will find 40 concise chapters covering 5 broad topics:
Career
Learning
Coding
Daily Life
Stories
Everyone has something unique to share. This book gathers together various perspectives and unique stories to give a well-rounded view of modern software development.