Book Review: Pro JavaFX 2

I'm a server side Java developer with 10 years experience, and 2 years experience in Adobe Flex. With Flex taking a recent slating in the press, I decided it was time to broaden my UI experiences to JavaFX and HTML 5 with Java Script. Because I know Java well, and having previous experiences with Swing, I chose JavaFX and this was the book I chose to help me learn the basics.

The first thing to note about this book is it's written by the key people behind the JavaFX technology. The advantage of this is the reader is immediately learning how the platform was designed and intended for use.

The book is split into 10 chapters, each with comprehensive code listings on how the examples and components are built. The chapters are outlined below, along with how I found them useful in the work we have been doing building a basic Java Memory Visualizer in JavaFX.

Getting a Jump Start in JavaFX

The book begins with a brief history of JavaFX, and discusses the original version and the introduction of 2.0. The book goes immediately into an example, building an application using a Java Class extending Application. There's also enough to get started in this chapter with getting Netbeans set up and ready to go to build your applications. There's a lot of content here, so don't let this put you off. There's some important code segments that you will probably need to flick back to along the way. My only observation at this point would be remember that there is still the option of using FXML to simplify a lot of the code that is in this chapter - so this chapter should be viewed as a primer.

Creating a User Interface in JavaFX

We're back out of the deep end now and will be walked through the scene and layouts of creating a typical user interface. This chapter is critical to when you come to build your own UIs. If you want to grab a chapter to help you get started quickly this would be the one. One minor criticism would be this would be a good chapter one, but I can appreciate why leading with an example is good. It really depends on your learning style if you want to read this chapter first. After some theory there is a whole host of examples for you to try and figure out, all with both screenshots and code samples. This is a real codex of information, for me I found reading the first part and trying the second part with my own examples worked best.

Properties and Bindings

Binding is a simple concept, but there are some subtleties that need to be appreciated when building JavaFX applications. The first part of the chapter is split into titles of Understanding X, which makes it easy to refer back to later. Once again, everything is backed up with an appropriate example that demonstrates the power of bindings. This chapter is similar to the previous, the first part of the chapter is easy to read for theory but the latter is example heavy. I'd use the latter part of the chapter as a reference to come back to once you start writing your own code.

Building Dynamic UI Layouts in JavaFX

We used the concepts that are in the Reversi example for the foundations of our Java Memory Visualizer to manipulate memory cells that are on the screen. This example is again in the format of extending Application, but building out components on there. We built our application using FXML based on the information from this chapter. There is enough in this chapter to build your own board game, or if you are building any binding state UI I'd recommend reading this chapter.

Using the JavaFX UI Controls

I personally haven't read this chapter in great depth as I view it as a reference chapter. It looks like this is the codex for building your own controls.

Collections and Concurrency

In chapter 6 we're really going back to basics, so in my opinion this is not a chapter you can shelve for later. For the collections part, if you are familiar with Flex, ObservableList reminded me of ArrayCollection. The concurrency section introduces the threading model that is used in JavaFX, and that it is single threaded like most other UI frameworks. The JavaFX tasks are then explained for removing logic from the main application thread to avoid bloating your application re-render. Personally when we approached this, due to the nature of the simulation, we used plain old java.util.concurrent.

Creating Charts in JavaFX

Great overview into building charts in JavaFX and shows off the power of what is capable in the API. Examples and screenshots are available to get you started with what you are trying to build.

Using the Media Classes

Because of the type of work I do it's likely I'll never get to do any of the fun stuff in this chapter. I've saved this one for a rainy day, although on a quick parse it does look like a chapter I will genuinely come back to.

Accessing Web Services

An awesome chapter with practical examples of how you would integrate your JavaFX client with real world technologies. This sample walks you through creating a REST API call to twitter, using JAXB to create an appropriate response and display the information. If you are looking at using this for EE work this would be a good chapter to read. 

JavaFX Languages Markup

In this chapter we see some other languages using JavaFX (Scala and Groovy). The finally we get to the section on FXML. The sample is fairly simple and somewhat limited, it would have been good to have seen more of this earlier. 

Summary

This is an excellent book to have if you are trying to do anything with JavaFX. Although the online documentation is getting better, this book provides an awesome introduction to most components, tricks and tips that you would need to get started in this space. My only criticism of the book is a lack of FXML examples and that it only really appears at the end of the book. This shouldn't take away however from some of the excellent explanations and examples in this unfamiliar space. It's also worth noting that with a bit of playing around it's very simple to convert the samples over to using FXML. 

5/5 - I bought this with my own money and don't want it back :-). 

Book Review: The Well Grounded Java Developer

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.