A comprehensive guide to help aspiring and professional C++ developers elevate the performance of their apps by allowing them to run faster and consume fewer resources Key Features Updated to C++20 with completely revised code and more content on error handling, benchmarking, memory allocators, and concurrent programming Explore the latest C++20 features including concepts, ranges, and coroutines Utilize C++ constructs and techniques to carry out effective data structure optimization and memory management Book DescriptionC++ High Performance, Second Edition guides you through optimizing the performance of your C++ apps. This allows them to run faster and consume fewer resources on the device they're running on without compromising the readability of your codebase. The book begins by introducing the C++ language and some of its modern concepts in brief. Once you are familiar with the fundamentals, you will be ready to measure, identify, and eradicate bottlenecks in your C++ codebase. By following this process, you will gradually improve your style of writing code. The book then explores data structure optimization, memory management, and how it can be used efficiently concerning CPU caches. After laying the foundation, the book trains you to leverage algorithms, ranges, and containers from the standard library to achieve faster execution, write readable code, and use customized iterators. It provides hands-on examples of C++ metaprogramming, coroutines, reflection to reduce boilerplate code, proxy objects to perform optimizations under the hood, concurrent programming, and lock-free data structures. The book concludes with an overview of parallel algorithms. By the end of this book, you will have the ability to use every tool as needed to boost the efficiency of your C++ projects. What you will learn Write specialized data structures for performance-critical code Use modern metaprogramming techniques to reduce runtime calculations Achieve efficient memory management using custom memory allocators Reduce boilerplate code using reflection techniques Reap the benefits of lock-free concurrent programming Gain insights into subtle optimizations used by standard library algorithms Compose algorithms using ranges library Develop the ability to apply metaprogramming aspects such as constexpr, constraints, and concepts Implement lazy generators and asynchronous tasks using C++20 coroutines Who this book is forIf you're a C++ developer looking to improve the efficiency of your code or just keen to upgrade your skills to the next level, this book is for you.

Explore GPU-enabled programmable environment for machine learning, scientific applications, and gaming using PuCUDA, PyOpenGL, and Anaconda Accelerate Key Features Understand effective synchronization strategies for faster processing using GPUs Write parallel processing scripts with PyCuda and PyOpenCL Learn to use the CUDA libraries like CuDNN for deep learning on GPUs Book DescriptionGPUs are proving to be excellent general purpose-parallel computing solutions for high performance tasks such as deep learning and scientific computing. This book will be your guide to getting started with GPU computing. It will start with introducing GPU computing and explain the architecture and programming models for GPUs. You will learn, by example, how to perform GPU programming with Python, and you'll look at using integrations such as PyCUDA, PyOpenCL, CuPy and Numba with Anaconda for various tasks such as machine learning and data mining. Going further, you will get to grips with GPU work flows, management, and deployment using modern containerization solutions. Toward the end of the book, you will get familiar with the principles of distributed computing for training machine learning models and enhancing efficiency and performance. By the end of this book, you will be able to set up a GPU ecosystem for running complex applications and data models that demand great processing capabilities, and be able to efficiently manage memory to compute your application effectively and quickly. What you will learn Utilize Python libraries and frameworks for GPU acceleration Set up a GPU-enabled programmable machine learning environment on your system with Anaconda Deploy your machine learning system on cloud containers with illustrated examples Explore PyCUDA and PyOpenCL and compare them with platforms such as CUDA, OpenCL and ROCm. Perform data mining tasks with machine learning models on GPUs Extend your knowledge of GPU computing in scientific applications Who this book is forData Scientist, Machine Learning enthusiasts and professionals who wants to get started with GPU computation and perform the complex tasks with low-latency. Intermediate knowledge of Python programming is assumed.

Learn how to configure, automate, orchestrate, troubleshoot, and monitor KVM-based environments capable of scaling to private and hybrid cloud models Key Features Gain expert insights into Linux virtualization and the KVM ecosystem with this comprehensive guide Learn to use various Linux tools such as QEMU, oVirt, libvirt, Cloud-Init, and Cloudbase-Init Scale, monitor, and troubleshoot your VMs on various platforms, including OpenStack and AWS Book DescriptionKernel-based Virtual Machine (KVM) enables you to virtualize your data center by transforming your Linux operating system into a powerful hypervisor that allows you to manage multiple operating systems with minimal fuss. With this book, you'll gain insights into configuring, troubleshooting, and fixing bugs in KVM virtualization and related software. This second edition of Mastering KVM Virtualization is updated to cover the latest developments in the core KVM components - libvirt and QEMU. Starting with the basics of Linux virtualization, you'll explore VM lifecycle management and migration techniques. You'll then learn how to use SPICE and VNC protocols while creating VMs and discover best practices for using snapshots. As you progress, you'll integrate third-party tools with Ansible for automation and orchestration. You'll also learn to scale out and monitor your environments, and will cover oVirt, OpenStack, Eucalyptus, AWS, and ELK stack. Throughout the book, you'll find out more about tools such as Cloud-Init and Cloudbase-Init. Finally, you'll be taken through the performance tuning and troubleshooting guidelines for KVM-based virtual machines and a hypervisor. By the end of this book, you'll be well-versed with KVM virtualization and the tools and technologies needed to build and manage diverse virtualization environments. What you will learn Implement KVM virtualization using libvirt and oVirt Delve into KVM storage and network Understand snapshots, templates, and live migration features Get to grips with managing, scaling, and optimizing the KVM ecosystem Discover how to tune and optimize KVM virtualization hosts Adopt best practices for KVM platform troubleshooting Who this book is forIf you are a systems administrator, DevOps practitioner, or developer with Linux experience looking to sharpen your open-source virtualization skills, this virtualization book is for you. Prior understanding of the Linux command line and virtualization is required before getting started with this book.

Learn how to deploy and test Linux-based Docker containers with the help of real-world use cases Key Features Understand how to make a deployment workflow run smoothly with Docker containers Learn Docker and DevOps concepts such as continuous integration and continuous deployment (CI/CD) Gain insights into using various Docker tools and libraries Book DescriptionDocker is the de facto standard for containerizing apps, and with an increasing number of software projects migrating to containers, it is crucial for engineers and DevOps teams to understand how to build, deploy, and secure Docker environments effectively. Docker for Developers will help you understand Docker containers from scratch while taking you through best practices and showing you how to address security concerns. Starting with an introduction to Docker, you'll learn how to use containers and VirtualBox for development. You'll explore how containers work and develop projects within them after you've explored different ways to deploy and run containers. The book will also show you how to use Docker containers in production in both single-host set-ups and in clusters and deploy them using Jenkins, Kubernetes, and Spinnaker. As you advance, you'll get to grips with monitoring, securing, and scaling Docker using tools such as Prometheus and Grafana. Later, you'll be able to deploy Docker containers to a variety of environments, including the cloud-native Amazon Elastic Kubernetes Service (Amazon EKS), before finally delving into Docker security concepts and best practices. By the end of the Docker book, you'll be able to not only work in a container-driven environment confidently but also use Docker for both new and existing projects. What you will learn Get up to speed with creating containers and understand how they work Package and deploy your containers to a variety of platforms Work with containers in the cloud and on the Kubernetes platform Deploy and then monitor the health and logs of running containers Explore best practices for working with containers from a security perspective Become familiar with scanning containers and using third-party security tools and libraries Who this book is forIf you're a software engineer new to containerization or a DevOps engineer responsible for deploying Docker containers in the cloud and building DevOps pipelines for container-based projects, you'll find this book useful. This Docker containers book is also a handy reference guide for anyone working with a Docker-based DevOps ecosystem or interested in understanding the security implications and best practices for working in container-driven environments.

Effectively deploy fully managed workloads using Google Cloud's serverless services Key Features Use real-world use cases to understand the core functionalities of Functions as a Service Explore the potential of Cloud Run, Knative, Cloud Build, Google Kubernetes Engine, and Cloud Storage Get to grips with architectural decisions, seamless deployments, containerization, and serverless solutions Book DescriptionGoogle Cloud's serverless platform allows organizations to scale fully managed solutions without worrying about the underlying infrastructure. With this book, you will learn how to design, develop, and deploy full stack serverless apps on Google Cloud. The book starts with a quick overview of the Google Cloud console, its features, user interface (UI), and capabilities. After getting to grips with the Google Cloud interface and its features, you will explore the core aspects of serverless products such as Cloud Run, Cloud Functions and App Engine. You will also learn essential features such as version control, containerization, and identity and access management with the help of real-world use cases. Later, you will understand how to incorporate continuous integration and continuous deployment (CI/CD) techniques for serverless applications. Toward the concluding chapters, you will get to grips with how key technologies such as Knative enable Cloud Run to be hosted on multiple platforms including Kubernetes and VMware. By the end of this book, you will have become proficient in confidently developing, managing, and deploying containerized applications on Google Cloud. What you will learn Explore the various options for deploying serverless workloads on Google Cloud Determine the appropriate serverless product for your application use case Integrate multiple lightweight functions to build scalable and resilient services Increase productivity through build process automation Understand how to secure serverless workloads using service accounts Build a scalable architecture with Google Cloud Functions and Cloud Run Who this book is forIf you are a cloud administrator, architect, or developer who wants to build scalable systems and deploy serverless workloads on Google Cloud, then this book is for you. To get the most out of this book, a basic understanding of the serverless ecosystem and cloud computing will be beneficial.

From fundamentals and design patterns to the different strategies for creating secure and reliable architectures in AWS cloud, learn everything you need to become a successful solutions architect Key Features Create solutions and transform business requirements into technical architecture with this practical guide Understand various challenges that you might come across while refactoring or modernizing legacy applications Delve into security automation, DevOps, and validation of solution architecture Book DescriptionBecoming a solutions architect gives you the flexibility to work with cutting-edge technologies and define product strategies. This handbook takes you through the essential concepts, design principles and patterns, architectural considerations, and all the latest technology that you need to know to become a successful solutions architect. This book starts with a quick introduction to the fundamentals of solution architecture design principles and attributes that will assist you in understanding how solution architecture benefits software projects across enterprises. You'll learn what a cloud migration and application modernization framework looks like, and will use microservices, event-driven, cache-based, and serverless patterns to design robust architectures. You'll then explore the main pillars of architecture design, including performance, scalability, cost optimization, security, operational excellence, and DevOps. Additionally, you'll also learn advanced concepts relating to big data, machine learning, and the Internet of Things (IoT). Finally, you'll get to grips with the documentation of architecture design and the soft skills that are necessary to become a better solutions architect. By the end of this book, you'll have learned techniques to create an efficient architecture design that meets your business requirements. What you will learn Explore the various roles of a solutions architect and their involvement in the enterprise landscape Approach big data processing, machine learning, and IoT from an architect's perspective and understand how they fit into modern architecture Discover different solution architecture patterns such as event-driven and microservice patterns Find ways to keep yourself updated with new technologies and enhance your skills Modernize legacy applications with the help of cloud integration Get to grips with choosing an appropriate strategy to reduce cost Who this book is forThis book is for software developers, system engineers, DevOps engineers, architects, and team leaders working in the information technology industry who aspire to become solutions architect professionals. A good understanding of the software development process and general programming experience with any language will be useful.

This book is a celebration of Leslie Lamport's work on concurrency, interwoven in four-and-a-half decades of an evolving industry: from the introduction of the first personal computer to an era when parallel and distributed multiprocessors are abundant. His works lay formal foundations for concurrent computations executed by interconnected computers. Some of the algorithms have become standard engineering practice for fault tolerant distributed computing - distributed systems that continue to function correctly despite failures of individual components. He also developed a substantial body of work on the formal specification and verification of concurrent systems, and has contributed to the development of automated tools applying these methods. Part I consists of technical chapters of the book and a biography. The technical chapters of this book present a retrospective on Lamport's original ideas from experts in the field. Through this lens, it portrays their long-lasting impact. The chapters cover timeless notions Lamport introduced: the Bakery algorithm, atomic shared registers and sequential consistency; causality and logical time; Byzantine Agreement; state machine replication and Paxos; temporal logic of actions (TLA). The professional biography tells of Lamport's career, providing the context in which his work arose and broke new grounds, and discusses LaTeX - perhaps Lamport's most influential contribution outside the field of concurrency. This chapter gives a voice to the people behind the achievements, notably Lamport himself, and additionally the colleagues around him, who inspired, collaborated, and helped him drive worldwide impact. Part II consists of a selection of Leslie Lamport's most influential papers. This book touches on a lifetime of contributions by Leslie Lamport to the field of concurrency and on the extensive influence he had on people working in the field. It will be of value to historians of science, and to researchers and students who work in the area of concurrency and who are interested to read about the work of one of the most influential researchers in this field.

Get up to speed with creational, structural, behavioral and concurrent patterns in Delphi to write clear, concise and effective code Key Features Delve into the core patterns and components of Delphi in order to master your application's design Brush up on tricks, techniques, and best practices to solve common design and architectural challenges Choose the right patterns to improve your program's efficiency and productivity Book DescriptionDesign patterns have proven to be the go-to solution for many common programming scenarios. This book focuses on design patterns applied to the Delphi language. The book will provide you with insights into the language and its capabilities of a runtime library. You'll start by exploring a variety of design patterns and understanding them through real-world examples. This will entail a short explanation of the concept of design patterns and the original set of the 'Gang of Four' patterns, which will help you in structuring your designs efficiently. Next, you'll cover the most important 'anti-patterns' (essentially bad software development practices) to aid you in steering clear of problems during programming. You'll then learn about the eight most important patterns for each creational, structural, and behavioral type. After this, you'll be introduced to the concept of 'concurrency' patterns, which are design patterns specifically related to multithreading and parallel computation. These will enable you to develop and improve an interface between items and harmonize shared memories within threads. Toward the concluding chapters, you'll explore design patterns specific to program design and other categories of patterns that do not fall under the 'design' umbrella. By the end of this book, you'll be able to address common design problems encountered while developing applications and feel confident while building scalable projects. What you will learn Gain insights into the concept of design patterns Study modern programming techniques with Delphi Keep up to date with the latest additions and program design techniques in Delphi Get to grips with various modern multithreading approaches Discover creational, structural, behavioral, and concurrent patterns Determine how to break a design problem down into its component parts Who this book is forHands-On Design Patterns with Delphi is aimed at beginner-level Delphi developers who want to build scalable and robust applications. Basic knowledge of Delphi is a must.

Design and implement professional level programs by exploring modern data structures and algorithms in Rust. Key Features Use data structures such as arrays, stacks, trees, lists and graphs with real-world examples Learn the functional and reactive implementations of the traditional data structures Explore illustrations to present data structures and algorithms, as well as their analysis, in a clear, visual manner. Book DescriptionRust has come a long way and is now utilized in several contexts. Its key strengths are its software infrastructure and resource-constrained applications, including desktop applications, servers, and performance-critical applications, not forgetting its importance in systems' programming. This book will be your guide as it takes you through implementing classic data structures and algorithms in Rust, helping you to get up and running as a confident Rust programmer. The book begins with an introduction to Rust data structures and algorithms, while also covering essential language constructs. You will learn how to store data using linked lists, arrays, stacks, and queues. You will also learn how to implement sorting and searching algorithms. You will learn how to attain high performance by implementing algorithms to string data types and implement hash structures in algorithm design. The book will examine algorithm analysis, including Brute Force algorithms, Greedy algorithms, Divide and Conquer algorithms, Dynamic Programming, and Backtracking. By the end of the book, you will have learned how to build components that are easy to understand, debug, and use in different applications. What you will learn Design and implement complex data structures in Rust Analyze, implement, and improve searching and sorting algorithms in Rust Create and use well-tested and reusable components with Rust Understand the basics of multithreaded programming and advanced algorithm design Become familiar with application profiling based on benchmarking and testing Explore the borrowing complexity of implementing algorithms Who this book is forThis book is for developers seeking to use Rust solutions in a practical/professional setting; who wants to learn essential Data Structures and Algorithms in Rust. It is for developers with basic Rust language knowledge, some experience in other programming languages is required.

Solve complex business problems by understanding users better, finding the right problem to solve, and building lean event-driven systems to give your customers what they really want Key Features Apply DDD principles using modern tools such as EventStorming, Event Sourcing, and CQRS Learn how DDD applies directly to various architectural styles such as REST, reactive systems, and microservices Empower teams to work flexibly with improved services and decoupled interactions Book DescriptionDevelopers across the world are rapidly adopting DDD principles to deliver powerful results when writing software that deals with complex business requirements. This book will guide you in involving business stakeholders when choosing the software you are planning to build for them. By figuring out the temporal nature of behavior-driven domain models, you will be able to build leaner, more agile, and modular systems. You'll begin by uncovering domain complexity and learn how to capture the behavioral aspects of the domain language. You will then learn about EventStorming and advance to creating a new project in .NET Core 2.1; you'll also and write some code to transfer your events from sticky notes to C#. The book will show you how to use aggregates to handle commands and produce events. As you progress, you'll get to grips with Bounded Contexts, Context Map, Event Sourcing, and CQRS. After translating domain models into executable C# code, you will create a frontend for your application using Vue.js. In addition to this, you'll learn how to refactor your code and cover event versioning and migration essentials. By the end of this DDD book, you will have gained the confidence to implement the DDD approach in your organization and be able to explore new techniques that complement what you've learned from the book. What you will learn Discover and resolve domain complexity together with business stakeholders Avoid common pitfalls when creating the domain model Study the concept of Bounded Context and aggregate Design and build temporal models based on behavior and not only data Explore benefits and drawbacks of Event Sourcing Get acquainted with CQRS and to-the-point read models with projections Practice building one-way flow UI with Vue.js Understand how a task-based UI conforms to DDD principles Who this book is forThis book is for .NET developers who have an intermediate level understanding of C#, and for those who seek to deliver value, not just write code. Intermediate level of competence in JavaScript will be helpful to follow the UI chapters.

A hands-on guide to creating, monitoring, and tuning a high performance Spring web application Key Features Understand common performance pitfalls and improve your application's performance Build and deploy strategies for complex applications using the microservice architecture Understand internals of JVM - the core of all Java Runtime Environments Book DescriptionWhile writing an application, performance is paramount. Performance tuning for real-world applications often involves activities geared toward detecting bottlenecks. The recent release of Spring 5.0 brings major advancements in the rich API provided by the Spring framework, which means developers need to master its tools and techniques to achieve high performance applications. Hands-On High Performance with Spring 5 begins with the Spring framework's core features, exploring the integration of different Spring projects. It proceeds to evaluate various Spring specifications to identify those adversely affecting performance. You will learn about bean wiring configurations, aspect-oriented programming, database interaction, and Hibernate to focus on the metrics that help identify performance bottlenecks. You will also look at application monitoring, performance optimization, JVM internals, and garbage collection optimization. Lastly, the book will show you how to leverage the microservice architecture to build a high performance and resilient application. By the end of the book, you will have gained an insight into various techniques and solutions to build and troubleshoot high performance Spring-based applications. What you will learn Master programming best practices and performance improvement with bean wiring Analyze the performance of various AOP implementations Explore database interactions with Spring to optimize design and configuration Solve Hibernate performance issues and traps Leverage multithreading and concurrent programming to improve application performance Gain a solid foundation in JVM performance tuning using various tools Learn the key concepts of the microservice architecture and how to monitor them Perform Spring Boot performance tuning, monitoring, and health checks Who this book is forIf you're a Spring developer who'd like to build high performance applications and have more control over your application's performance in production and development, this book is for you. Some familiarity with Java, Maven, and Eclipse is necessary.

Immerse yourself in the world of Python concurrency and tackle the most complex concurrent programming problems Key Features Explore the core syntaxes, language features and modern patterns of concurrency in Python Understand how to use concurrency to keep data consistent and applications responsive Utilize application scaffolding to design highly-scalable programs Book DescriptionPython is one of the most popular programming languages, with numerous libraries and frameworks that facilitate high-performance computing. Concurrency and parallelism in Python are essential when it comes to multiprocessing and multithreading; they behave differently, but their common aim is to reduce the execution time. This book serves as a comprehensive introduction to various advanced concepts in concurrent engineering and programming. Mastering Concurrency in Python starts by introducing the concepts and principles in concurrency, right from Amdahl's Law to multithreading programming, followed by elucidating multiprocessing programming, web scraping, and asynchronous I/O, together with common problems that engineers and programmers face in concurrent programming. Next, the book covers a number of advanced concepts in Python concurrency and how they interact with the Python ecosystem, including the Global Interpreter Lock (GIL). Finally, you'll learn how to solve real-world concurrency problems through examples. By the end of the book, you will have gained extensive theoretical knowledge of concurrency and the ways in which concurrency is supported by the Python language What you will learn Explore the concepts of concurrency in programming Explore the core syntax and features that enable concurrency in Python Understand the correct way to implement concurrency Abstract methods to keep the data consistent in your program Analyze problems commonly faced in concurrent programming Use application scaffolding to design highly-scalable programs Who this book is forThis book is for developers who wish to build high-performance applications and learn about signle-core, multicore programming or distributed concurrency. Some experience with Python programming language is assumed.

Take advantage of Kotlin's concurrency primitives to write efficient multithreaded applications Key Features Learn Kotlin's unique approach to multithreading Work through practical examples that will help you write concurrent non-blocking code Improve the overall execution speed in multiprocessor and multicore systems Book DescriptionThe primary requirements of modern-day applications are scalability, speed, and making the most use of hardware. Kotlin meets these requirements with its immense support for concurrency. Many concurrent primitives of Kotlin, such as channels and suspending functions, are designed to be non-blocking and efficient. This allows for new approaches to concurrency and creates unique challenges for the design and implementation of concurrent code. Learning Concurrency in Kotlin addresses those challenges with real-life examples and exercises that take advantage of Kotlin's primitives. Beginning with an introduction to Kotlin's coroutines, you will learn how to write concurrent code and understand the fundamental concepts needed to be able to write multithreaded software in Kotlin. You'll explore how to communicate between and synchronize your threads and coroutines to write asynchronous applications that are collaborative. You'll also learn how to handle errors and exceptions, as well as how to leverage multi-core processing. In addition to this, you'll delve into how coroutines work internally, allowing you to see the bigger picture. Throughout the book you'll build an Android application - an RSS reader - designed and implemented according to the different topics covered in the book What you will learn Understand Kotlin's approach to concurrency Implement sequential and asynchronous suspending functions Create suspending data sources that are resumed on demand Explore the best practices for error handling Use channels to communicate between coroutines Uncover how coroutines work under the hood Who this book is forIf you're a Kotlin or Android developer interested in learning how to program concurrently to enhance the performance of your applications, this is the book for you.

Create distributed applications with clever design patterns to solve complex problems Key Features Set up and run distributed algorithms on a cluster using Dask and PySpark Master skills to accurately implement concurrency in your code Gain practical experience of Python design patterns with real-world examples Book DescriptionThis Learning Path shows you how to leverage the power of both native and third-party Python libraries for building robust and responsive applications. You will learn about profilers and reactive programming, concurrency and parallelism, as well as tools for making your apps quick and efficient. You will discover how to write code for parallel architectures using TensorFlow and Theano, and use a cluster of computers for large-scale computations using technologies such as Dask and PySpark. With the knowledge of how Python design patterns work, you will be able to clone objects, secure interfaces, dynamically choose algorithms, and accomplish much more in high performance computing. By the end of this Learning Path, you will have the skills and confidence to build engaging models that quickly offer efficient solutions to your problems. This Learning Path includes content from the following Packt products: Python High Performance - Second Edition by Gabriele Lanaro Mastering Concurrency in Python by Quan Nguyen Mastering Python Design Patterns by Sakis Kasampalis What you will learn Use NumPy and pandas to import and manipulate datasets Achieve native performance with Cython and Numba Write asynchronous code using asyncio and RxPy Design highly scalable programs with application scaffolding Explore abstract methods to maintain data consistency Clone objects using the prototype pattern Use the adapter pattern to make incompatible interfaces compatible Employ the strategy pattern to dynamically choose an algorithm Who this book is forThis Learning Path is specially designed for Python developers who want to build high-performance applications and learn about single core and multi-core programming, distributed concurrency, and Python design patterns. Some experience with Python programming language will help you get the most out of this Learning Path.

Get writing tests and learn to design your own testing framework with Selenium WebDriver API Key Features Learn Selenium from the ground up Design your own testing framework Create reusable functionality in your framework Book DescriptionSelenium WebDriver is a platform-independent API for automating the testing of both browser and mobile applications. It is also a core technology in many other browser automation tools, APIs, and frameworks. This book will guide you through the WebDriver APIs that are used in automation tests. Chapter by chapter, we will construct the building blocks of a page object model framework as you learn about the required Java and Selenium methods and terminology. The book starts with an introduction to the same-origin policy, cross-site scripting dangers, and the Document Object Model (DOM). Moving ahead, we'll learn about XPath, which allows us to select items on a page, and how to design a customized XPath. After that, we will be creating singleton patterns and drivers. Then you will learn about synchronization and handling pop-up windows. You will see how to create a factory for browsers and understand command design patterns applicable to this area. At the end of the book, we tie all this together by creating a framework and implementing multi-browser testing with Selenium Grid. What you will learn Understand what an XPath is and how to design a customized XPath Learn how to create a Maven project and build Create a Singleton driver Get to grips with Jenkins integration Create a factory for browsers Implement multi-browser testing with Selenium Grid Create a sample pop-up window and JavaScript alert Report using Extent Reports Who this book is forThis book is for software testers or developers.