The Best JVM Books of All Time

Effectively reading and understanding existing code is a developer’s superpower. In this book, you’ll master techniques for code profiling, advanced debugging, and log evaluation to find and fix bugs and performance problems. In Troubleshooting Java: Read, debug, and optimize JVM applications you will learn how to:. Determine what code does the first time you see it. Expose code logic problems. Evaluate heap dumps to find memory leaks. Monitor CPU consumption to optimize execution. Use thread dumps to find and solve deadlocks. Easily follow a service-oriented or microservices system.

Properly use logging to better understand Java app execution. Use Java debuggers efficiently. Searching for bugs, detangling messy legacy code, or evaluating your codebase for new features sucks up much of a developer's time. Troubleshooting Java: Read, debug, and optimize JVM applications teaches code investigation techniques that will help you efficiently understand how Java apps work, how to optimize them, and how to fix the bugs that break them. You’ll go from the basics of debugging to advanced methods for locating problems in microservices architectures, and save yourself hours—or even days—of time. Each new technique is explained with lively illustrations and engaging real-world examples. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology. Fact: Over the course of your career, you’ll spend far more time reading code than you will writing it. The code investigation skills in this book will radically improve your efficiency in understanding and improving Java applications. About the book. Troubleshooting Java: Read, debug, and optimize JVM applications presents practical techniques for exploring and repairing unfamiliar code. In it, you’ll learn timesaving practices for discovering hidden dependencies, discovering the root causes of crashes, and interpreting unexpected results. Go beyond profiling and debugging and start understanding how Java applications really work. What's inside. Determine what code does the first time you see it. Evaluate heap dumps to find memory leaks. Monitor CPU consumption to optimize execution. Use thread dumps to find and solve deadlocks. Uncover glitches in code logic. Locate intermittent runtime problems. About the reader. For intermediate Java developers. About the author. Laurentiu Spilca is a skilled Java and Spring developer and an experienced technology instructor. He is the author of Spring Start Here and Spring Security in Action. Table of Contents. PART 1 - THE BASICS OF INVESTIGATING A CODEBASE. 1 Revealing an app’s obscurities. 2 Understanding your app’s logic through debugging techniques. 3 Finding problem root causes using advanced debugging techniques. 4 Debugging apps remotely. 5 Making the most of logs: Auditing an app’s behavior. PART 2 - DEEP ANALYSIS OF AN APP’S EXECUTION. 6 Identifying resource consumption problems using profiling techniques. 7 Finding hidden issues using profiling techniques. 8 Using advanced visualization tools for profiled data. 9 Investigating locks in multithreaded architectures. 10 Investigating deadlocks with thread dumps. 11 Finding memory-related issues in an app’s execution. PART 3 - FINDING PROBLEMS IN LARGE SYSTEMS. 12 Investigating apps’ behaviors in large systems.

Understand the internals and architecture of GraalVM with the help of hands-on experiments and gain deep knowledge that you can apply to improve your application's performance, interoperability, and throughput. Key Features:. Generate faster and leaner code with minimum computing resources for high performanceCompile Java applications faster than ever to a standalone executable called native imagesCreate high-performance polyglot applications that are compatible across various JVM and non-JVM languages. Book Description:.

GraalVM is a universal virtual machine that allows programmers to compile and run applications written in both JVM and non-JVM languages. It improves the performance and efficiency of applications, making it an ideal companion for cloud-native or microservices-based applications. This book is a hands-on guide, with step-by-step instructions on how to work with GraalVM. Starting with a quick introduction to the GraalVM architecture and how things work under the hood, you'll discover the performance benefits of running your Java applications on GraalVM. You'll then learn how to create native images and understand how AOT (ahead-of-time) can improve application performance significantly. The book covers examples of building polyglot applications that will help you explore the interoperability between languages running on the same VM. You'll also see how you can use the Truffle framework to implement any language of your choice to run optimally on GraalVM. By the end of this book, you'll not only have learned how GraalVM is beneficial in cloud-native and microservices development but also how to leverage its capabilities to create high-performing polyglot applications. What You Will Learn:. Gain a solid understanding of GraalVM and how it works under the hoodWork with GraalVM's high performance optimizing compiler and see how it can be used in both JIT (just-in-time) and AOT (ahead-of-time) modesGet to grips with the various optimizations that GraalVM performs at runtimeUse advanced tools to analyze and diagnose performance issues in the codeCompile, embed, run, and interoperate between languages using Truffle on GraalVMBuild optimum microservices using popular frameworks such as Micronaut and Quarkus to create cloud-native applications. Who this book is for:. This book is for JVM developers looking to optimize their application's performance. You'll also find this book useful if you're a JVM developer looking to explore options to develop polyglot applications using tools from the Python, R, Ruby, or Node.js ecosystem. A solid understanding of software development concepts and prior experience working with programming languages is necessary to get started.

Get up to speed on Scala--the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You'll learn why Scala is ideal for building today's highly scalable, data-centric applications, while maximizing developer productivity. While Java remains popular and Kotlin has become popular, Scala hasn't been sitting still. This third edition covers the new features in Scala 3.0 with updates throughout the book.

Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala's design philosophy and features with a thoroughly practical focus. Program faster with Scala's succinct and flexible syntax Dive into basic and advanced functional programming techniques Build killer big data and distributed apps using Scala's functional combinators and tools like Spark and Akka Create concise solutions to challenging design problems with the sophisticated type system, mixin composition with traits, pattern matching, and more.