I have been a Java developer for over 10 years, with 5 years of this in the financial software industry. In my opinion this book is one of the best Java books on the market currently. There is something in this book for everyone, if you are new graduate it helps to consolidate your skills in Java. If you're an old hat, this book has a refreshing approach to more complex topics, such as Understanding Performance Tuning which Dr Heinz Kabutz brands as: "The first book since Jack Shirazi’s Java Performance Tuning that has captured the essence of how to make your system faster." in the foreword. I think the two chapters understanding performance tuning and modern concurrency are a must read for all developers, and are delivered superbly for all levels.
The book is split into 4 parts, starting with an introduction to Java 7. Anyone who has been asleep for the last year should definitely be reading this section. It presents all the major changes with examples, and is easy to follow and read.
Vital techniques then takes a deep dive into dependency injection - critical to writing testable and maintainable code. The section shows by example an introduction to the critical topic. It also introduces JSR-330 annotations, which as an early adopter of Spring I hadn't looked at in detail myself. The spin then goes into concurrency, and this chapter I finished! Having had Modern Concurrency in Practice on the bookshelf, 4 attempts at reading it and bottoming out around page 50 - I have to say this was refreshing. Modern Concurrency is a great book, but this chapter synthesises the complexity in simple and easy to understand diagrams and explanations. Class files and byte code is another section that many Java developers lack a detailed understanding of - this book adequately covers this topic. It also introduce the opcode detail of invoke dynamic and how that will be useful for developers. The final chapter in this section dives in to understanding performance tuning, which takes a very pragmatic and evidence based approach to finding out why your application might be running "badly". I like this section a lot because it's written from experience, some of the same problems I have run into in my career could have been avoided by reading this chapter first. It also goes into detail about garbage collection basics and structures, a topic which is usually a guaranteed interview question. Also if you thought that Objects were always allocated on the heap, check out page 181 for something you might have missed :-).
At this point your brain might be fried, if so another read of it will make everything clearer. There's hints and tips in the sections for stuff you can skip and that's really useful for the first parse. The next section is slightly easier going and introduces polygot programming on the JVM. If you haven't come across many functional languages this starts with introducing the key concepts and how the compare with traditional Java approaches. We then get the detail of how this all works and we're ready to go with trying out our first functional languages. We get a overview introduction to Groovy, Scala and Clojure. I didn't read these chapters in too much detail purely because of the work I'm doing at the moment. However, I did like the presentation format of is this right for my project, some of the higher level concepts (with solid examples) as well as interoperability with Java. To me this is going to be my holiday reading to see what is going on outside the core space, providing a primer that will be enough for me to go off and do my own research and experimentation.
The final part is about craft, craft is perhaps the one thing that is missing from day to day developers I come across. Craft makes you stand out, it makes you professional and caring about the product that you will deliver. This is one skill you can't get a qualification for, it grows from experience, learning from other and striving to deliver the best you can. The section introduces some key points and approaches you can apply starting today. The chapter on test driven development is another hidden gem in this book, having worked at establishment where testing is finding the problem in production this introduction brought about a new approach to the way me (and my team) now go about writing code. This approach gives you the building blocks of learning these valuable techniques and gives you some hints and tips into different tools you can use to support you with this. Writing good code is all well and good, but how do you ensure it works well with other people's changes and passes coding standards? The continuous integration chapter details how this works using Jenkins as the example. Of course no section of building would be complete without a mention of Maven, I'll let you decide if that's a good or a bad thing :-)!
The book wraps up with web development and looks at why Java is not necessarily the best tool in the box for this, followed by how to stay well grounded now you have been armed with a book!
I have bought and read many technical books in the past and there are only two technical books I've ever read cover to cover, Spring in Action was one of them this is the other. The book focuses on Java 7, which although out for a year is slowly creeping into production systems. The book serves as a good primer to the new changes.
Note:
I wouldn't consider this a very beginner book, if you are looking to learn object oriented programming from the beginning I'd recommend reading another book first. It's not criticism of the book, but if that's what you're looking for I'd consider this book as the second book you buy.
No comments:
Post a Comment