Gradle Essentials (Community Experience Distilled)

The only relatively recently published (circa early-2018) text on mastering Gradle fundamentals. Although I have been a long-time Apache Maven user, I admittedly resisted a move to Gradle a few years ago when some of my colleagues had done so, mainly because they could not explain any benefits of using it other than commenting that project dependencies are relatively terse with Graven compared to Maven, which in my opinion did not justify a switch in itself. While I still view Apache Maven as the de facto build automation tool for Java projects, I was recently in a position where Gradle had been preemptively chosen for a development project and I needed to get up to speed using it in conjunction with IntelliJ IDEA (as is the case with Maven, I have also been a long-time Eclipse user). In working through this book, I fortunately discovered that Gradle provides more benefits than just dependency management.To ramp up on Gradle, I got going by working through the first 5 of 9 chapters provided, and then following up by working through real projects, although I did end up skimming through the last 4 chapters to get familiar with the content that these provide. Developers interested in reading through this book will likely have differing needs, as is the case with most technology texts. For example, usage of the Jenkins automation server and SonarQube static code quality analysis platform that can be used with Jenkins is briefly covered, and I glossed over this content due to my extensive usage of both tools (including Jenkins from its early days several years ago when it was called Hudson). I also took a look at what the authors had to write about migrating from Apache Maven to Gradle, but what they provide is only 2-pages of content. While it has been a long time since I've used Apache Ant to any great extent, some readers might be interested in the pages covering a move from Ant to Gradle in the preceding pages, but 4-pages of material will likely only go so far.Most of the exercises covered in the first 5 chapters worked as intended, although I soon came across Gradle version related differences that begin at the tail end of chapter 1. For example, executing the code at the top of page 12 resulted in the following message: "The Task.leftShift(Closure) method has been deprecated and is scheduled to be removed in Gradle 5.0." And executing the code presented in the 1-page discussion of the benefits of using the Gradle Daemon does not result in the output provided by the authors. As I was curious why this was the case, I referenced the Gradle user guide which states the following: "The Gradle Daemon is enabled by default starting with Gradle 3.0, so you don't have to do anything to benefit from it."Other than some other anomalies, such as inconsistent versions of JUnit being used in chapter 2 examples (sometimes JUnit 4.11, sometimes JUnit 4.12), some potential users of this guide might be interested in knowing that the primer the authors provide in chapter 4 starts off on the wrong foot in the initial section entitled "Running Groovy code": the authors state several times that "we can use" this and "we can use" that, but they don't actually show you how to do the listed tasks. For example, I needed to look up how to install the latest Groovy SDK locally, as well as how to execute the Groovy console GUI at the command line using "groovyConsole". I don't think it's too much to ask the authors to include the few additional lines of code needed to perform these tasks, or at least to point readers in the right direction by providing URLs for additional information.When all is said and done, I recommend this book because it is a relatively quick guide to work through, and the issues previously mentioned don't seriously distract from what is presented. If anything, these will force readers to not go through the motions of understanding the material, and will additionally get readers to get more familiar with the Gradle documentation and community. As explained by the authors midway through the text, Gradle build scripts use the Groovy syntax as well as a rich and expressive DSL that provides high-level abstractions to represent common build-related logic. As a final note, I recall when Groovy reached peek popularity several years ago when my colleagues started writing scripts with the language. However, it has recently become so closely tied to Gradle usage that I recently overheard a developer at work commenting how "Groovy is a DevOps language", even though it has been around for quite some time: making this same mistake will likely expose your relative inexperience to more senior resources around you.

Having first encountered mysterious and incomprehensible (to me) build.gradle files in online collaborations, I finally decided to see what all the fuss was about and bought this book to learn Gradle from scratch. I'm glad I did! In less than 2 hours, I was writing and customizing my own Gradle build scripts. This book is easy to read and full of examples.I highly recommend this book to anyone interested in learning Gradle, especially those who scoff at one-line build.gradle files for their apparent opacity and lack of implementation details (as I once did). This book does not assume that you know Maven (I certainly don't) or any other particular build tool.To get the most out of this book, however, you will need a little bit of Java programming knowledge. If you have ever made a Java program that runs from a .jar file or used a class library stored in a .jar file, then you won't have any trouble.My only other critique of this book would be that I wish it had told me to go look at the official Gradle documentation for the Java plugin right after explaining it, to further demystify the nuts-and-bolts of Gradle.

This book does a fair job of introducing Gradle at a high level. However, I picked up both this book and Mastering Gradle in order to try to make some sense of a project our team inherited that recently switched from Ant to Gradle, and after going through this book I still can't make heads or tails of the Gradle setup. I'm really hoping Mastering Gradle will get us further along.Aside from that, I have to say the editing in this book is severely lacking.

The book is true to its title - Gradle "Essentials." I've followed the first three chapters so far and the material enhanced the little knowledge I had about Gradle. If you don't know Gradle and need help scratching the surface, this book is easy to follow. It helped that I knew Maven already, but this book gives you the fundamentals.

A quick and easy introduction to Gradle.

Like other so so books, sparse, not great ar framing the process and explaining, just my opinion.

le faltarian unos ejemplos intermedios avanaza muy rápido

Succinct like the title suggests. Good read overall and especially for demystifying some of the cryptic syntax used by gradle/groovy.

Je le recommande:- Intro à Groovy, language de scripting utilisé par Gradle- La philosophie de Gradle, son organisation, etc.- Et comment l'utiliser dans un contexte CI, etc.Ce n'est pas non plus un bouquin exhaustif (que 150 pages), mais juste suffisant pour rentrer dans Gradle.Bref, ravi.