دانلود کتاب توسعه‌ خوب جاوا – ویرایش دوم

The first edition of this book started life as a set of training notes written for new graduate developers in the foreign exchange department of a bank. One of us (Ben), looking at the existing books on the market, found a lack of up-to-date material aimed at Java developers who wanted to level up. Partway through writing that material, he found he was writing that missing book and enlisted Martijn to help. That was more than 10 years ago—we were writing as Java 7 was being developed— and the world is very different now. In response, the book has changed substantially since the first edition. So, although our original primary goals were to introduce topics like ■ Polyglot programming ■ Dependency injection ■ Multithreaded programming ■ Sound build and CI practices ■ What’s new in Java 7 when we came to write the second edition, we found that we needed to make some changes, including ■ Trimming down polyglot a bit ■ Adding a new emphasis on functional programming ■ Enhancing the discussion of multithreading ■ Putting a different spin on build and deploy (including containers) ■ Talking about what’s new in Java 11 and 17

One very important change was that the first edition included Scala as one of three non-Java languages discussed (the others being Groovy and Clojure—Kotlin didn’t really exist at the time we wrote it). At that time, many of the developers exploring Scala were looking for “Java, but a better mousetrap,” which is essentially the view of Scala that we presented in the first edition. However, since then, the world has moved on. Java 8 and 11 became hugely dominant, and the “better mousetrap” crew are mostly writing Kotlin (or just sticking with Java). Scala, in the meantime, has become a very powerful statically typed, FP-first JVM language. This is great for the folks who want that, but it has come with costs, such as an ever-more-complex runtime and a language that has less and less in common with Java as time goes by. This development is sometimes abbreviated to the phrase that “Scala wants to be Haskell on the JVM,” although this is not entirely accurate and is more a convenient conversational shorthand than anything else. So, after having made the decision to drop Groovy from the second edition, we thought long and hard about whether to keep Scala or replace it with Kotlin. Our eventual conclusion was basically that Scala is heading in its own, FP-heavy direction, and that we wanted to present a language that was more approachable to Java developers who were coming fresh to non-Java languages, such as Kotlin. This left us with a dilemma. The parts of Scala that are easily accessible to Java folks are very similar to Kotlin (with near-identical syntax in some cases), but the philosophy and direction of travel of the two languages are totally different. We felt that explaining what Scala is in sufficient depth—so that the coverage was distinct from Kotlin— would take up far too much space in the book. Therefore, our eventual decision was to drop from three to two additional languages to make space and give extra depth to the coverage of the remaining languages (Kotlin and Clojure). For this reason, although we make the occasional comment about Scala, we don’t devote entire sections (let alone chapters) to it. Clojure is a very different story—and, indeed, a very different language—than either Kotlin or Java. For example, in chapter 15 we struggle a bit because many of the concepts that we’re introducing in the other languages (e.g., higher-order functions and recursion) have already been introduced and are just “part of the landscape” in Clojure. Rather than follow the template used by Java and Kotlin, the discussion goes in a different direction. Clojure is, fundamentally, a much more functionally oriented language, and we would just end up repeating ourselves a lot if we were to follow the exact same structure as for the other languages. In this book, we hope that the theme of software development as a social activity rings out clearly. We believe that the technical aspects of the craft are important, but the more subtle concerns of communication and interaction between people are at least as important. It can be hard to explain these facets easily in a book, but that theme is present throughout.