Unit Testing: Principles, Practices and Patterns is a practical guide to modern unit testing best practices. Microsoft MVP Vladimir Khorikov takes you hands-on with examples of the ideal unit test and unit testing practices, building your skills step by step on a solid foundation. You’ll explore how to design and write tests that check the right aspects of your applications, develop effective and maintainable test suites, and automate your testing process safely. When you are done, you will have a best practice testing suite that ensures your projects are easier to maintain, easier to scale, and easier to adapt to changing needs.
what's inside
A universal frame of reference by which to assess any unit test
Common anti-patterns to identify and avoid
Guidelines on how to refactor a test suite along with the production code it covers
Using integration tests to verify the behavior of the system as a whole

In Microservices: A Practical Guide, architecture expert Eberhard Wolff starts by introducing microservices, self-contained systems, and the migration to microservices architecture. You’ll then move on to cookbook-style recipes that answer the most common challenges and operations of implementing microservices, including client-side and server-side frontend integration, asynchronous microservices, synchronous systems, and utilizing microservices platforms such as Kubernetes, Istio, and Cloud Foundry. Each recipe is fully illustrated with demo code and suggested variations that make them easy to adapt to your needs. By the time you’re done, you’ll have the skills to start implementing microservices architecture and a handy guide to consult as you work.
what's inside
Migrating to microservices
Frontend Integration with JavaScript and Edge Side Includes
Asynchronous microservices with Apache Kafka or REST/Atom
Synchronous microservices with the Netflix Stack or Consul
Microservice platforms: Kubernetes, Cloud Foundry, or Istio
Monitoring with Prometheus
Log Analysis with Elasticsearch and Kibana
Tracing with Zipkin

Coding and testing are often considered separate areas of expertise. In this comprehensive guide, author and Java expert Scott Oaks takes the approach that anyone who works with Java should be equally adept at understanding how code behaves in the JVM, as well as the tunings likely to help its performance.
You’ll gain in-depth knowledge of Java application performance, using the Java Virtual Machine (JVM) and the Java platform, including the language and API. Developers and performance engineers alike will learn a variety of features, tools, and processes for improving the way Java 7 and 8 applications perform.
Apply four principles for obtaining the best results from performance testing
Use JDK tools to collect data on how a Java application is performing
Understand the advantages and disadvantages of using a JIT compiler
Tune JVM garbage collectors to affect programs as little as possible
Use techniques to manage heap memory and JVM native memory
Maximize Java threading and synchronization performance features
Tackle performance issues in Java EE and Java SE APIs
Improve Java-driven database application performance

Get more out of your legacy systems: more performance, functionality, reliability, and manageability

Is your code easy to change? Can you get nearly instantaneous feedback when you do change it? Do you understand it? If the answer to any of these questions is no, you have legacy code, and it is draining time and money away from your development efforts.

In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control.

The topics covered include

Understanding the mechanics of software change: adding features, fixing bugs, improving design, optimizing performance
Getting legacy code into a test harness
Writing tests that protect you against introducing new problems
Techniques that can be used with any language or platform—with examples in Java, C++, C, and C#
Accurately identifying where code changes need to be made
Coping with legacy systems that aren't object-oriented
Handling applications that don't seem to have any structure
This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.



© Copyright Pearson Education. All rights reserved.

It's not easy to design good application interfaces in a world where companies must create compelling, seamless user experiences across an exploding number of channels, screens, and contexts. Design patterns, design systems, and component-based UI frameworks have emerged and now rapidly evolve to meet the challenge.
This bestselling book is one of the few reliable sources to help you navigate through the maze of design options. By capturing UI best practices and reusable ideas as design patterns, Designing Interfaces provides solutions to common design problems that you can tailor to the situation at hand.
This updated edition includes patterns for mobile apps and social media, as well as web applications and desktop software. Each pattern contains full-color examples and practical design advice that you can use immediately. Experienced designers can use this guide as a sourcebook of ideas; novices will find a roadmap to the world of interface and interaction design.

Programming with Types teaches you to design safe, resilient, correct software that’s easy to maintain and understand by taking advantage of the power of strong type systems. Designed to provide practical, instantly-useful techniques for working developers, this clearly-written tutorial introduces you to using type systems to support everyday programming tasks. In it, you’ll explore the impact types have on functions, inheritance, and composition, and you’ll take a close look at generics, which enable greater abstraction. You’ll also discover folding data structures and applying functions to containers with higher kinded types. Along the way, you’ll explore real-world use cases and practical examples in TypeScript as you build your skills from primitive types up to more advanced concepts like functors and monads.
what's inside
An introduction to type systems and their benefits
Designing functions that don’t return values
Encoding text
Building data structures with arrays and references
Type composition
Function types
Type safety
Asynchronous functions
Subtyping
Object-oriented programming with types
Generic data structures and algorithms

Get Programming with Clojure guides you through exercises, examples, and projects that teach you to build fast, robust, applications with Clojure. Under Yehonathan Sharvit’s expert instruction, you’ll begin by getting comfortable with Clojure’s Lisp-y syntax. Then, you’ll start writing short programs that introduce functional programming principles like immutability, data-orientation, and first-class functions. After two or three small projects, you’ll be ready to drill down to more advanced concepts including logic operations, vectors and maps, lazy sequences, pure and high-order functions, and state management.
Throughout this hands-on book, you’ll work with the custom interactive Klipse Clojure REPL environment—developed by the author himself!—where you’ll quickly appreciate the productivity benefits of evaluating and modifying expressions from the command line. Capstone projects at the end of each set of short, focused lessons seal in all you’ve learned. You’ll grow your skills step-by-step as you explore building and deploying a Clojure program that handles real-life challenges like the management of a bank account. By the end of the book, you’ll be well-prepared to move on to developing ecommerce web servers, writing front-end apps, publishing your own Clojure libraries, and more!
what's inside
Mastering Clojure syntax
Working with immutable data collections
Functions as first-class objects
Evaluating expressions in the Clojure REPL environment
Composing a pipeline for manipulating data
Capstone projects ranging from a bank account manager to a string composer

Graph Databases in Action teaches you everything you need to know to begin building and running applications powered by graph databases. Right off the bat, seasoned graph database experts and authors Dave Bechberger and Josh Perryman introduce you to just enough graph theory, the graph database ecosystem, and a variety of datastores. You’ll also explore modelling basics in action with real-world examples, then go hands-on with querying, coding traversals, parsing results, and other essential tasks as you build your own graph-backed social network app complete with a recommendation engine!
With valuable firsthand experience under your belt, you’re ready for advanced concepts including query tuning, data model tuning, evolving your graphs, and pitfalls and anti-patterns like supernodes, hidden entities, and anemic edges. All examples are presented in the open source Apache TinkerPop framework and the Gremlin language, and almost all concepts and constructs are compatible with Cypher/openCypher databases such as Neo4j. With this comprehensive guide, you’ll be building graph-powered applications that dramatically increase the value of data—as well as your professional value to the companies savvy enough to use them!
what's inside
Graph database fundamentals
An overview of the graph database ecosystem
Relational vs. graph database modelling
Querying graphs using Gremlin
Real-world common graph use cases
Basic graph algorithms
A hands-on graph-backed application project
Performance tuning
Pitfalls and anti-patterns
Graph analytics

Turn the corner from “Haskell student” to “Haskell developer.” Haskell in Depth explores the important language features and programming skills you’ll need to build production-quality software using Haskell. And along the way, you’ll pick up some interesting insights into why Haskell looks and works the way it does. Get ready to go deep!
Haskell in Depth is the perfect second book on Haskell. After a quick refresher on Haskell basics, this hands-on guide dives into examples and application scenarios designed to teach how Haskell works and how to apply it correctly. You’ll learn about managing projects with Cabal and Stack, tackle error-handling and testing, and package programs and libraries for production deployment.
You’ll appreciate coverage of advanced Haskell features including programming polymorphically, working effectively with types, concurrent programming, data processing, web services, and more. Because it’s organized to make specific topics easy to find, you’ll return to this book again and again as your go-to Haskell reference.

Algorithms and Data Structures in Action introduces you to a diverse range of algorithms you’ll use in web applications, systems programming, and data manipulation. Chapter-by-chapter, the book expands on the basic algorithms you’ll already know to give you a better selection of solutions to different programming problems. In it, you’ll discover techniques for improving priority queues, efficient caching, clustering data, and more. Each example is fully illustrated with graphics, language-agnostic pseudo-code, and code samples in various languages. When you’re done, you will be able to implement advanced and little-known algorithms to deliver better performance from your code. You’ll even have the skills to design your own data structures to solve those cases when a custom solution is required.
what's inside
Improving on basic data structures
Efficient caching
Nearest neighbour search, including k-d trees and S-trees
Full ‘pseudo-code’ and samples in multiple languages

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.

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.