Page 1 of 1

Book Review: Murach's Beginning Java with NetBeans Rate Topic: -----

#1 baavgai  Icon User is offline

  • Dreaming Coder
  • member icon

Reputation: 6379
  • View blog
  • Posts: 13,629
  • Joined: 16-October 07

Posted 21 October 2015 - 10:43 AM

Attached Image
Murach's Beginning Java with NetBeans

First, some words from our publisher


We've designed Murach's Beginning Java with NetBeans specifically for beginning programmers and programmers with limited experience who want to learn Java at a professional level. By the time you finish this book, youíll have all the core Java skills that you need to move on to web or Android programming.
-- https://www.murach.c...netbeans-detail

We hope it will show you how easy it is to learn from any Murach book, with its paired-pages presentation, its 'how-to' headings, its practical coding examples, and its clear, concise style.
-- First chapter PDF intro

The Book Itself
The style is worth noting, and quoting, because it is a huge selling point. The company has chosen to make generous use of white space and faithfully adhere to a consistent organizational style. As a result, having the book open in front of you will usually offer a complete concept in both detailed and highlighted form. As with any programming book, when you go back to it you'll want just those highlights and here they are easy to find. Also, if you're like me, you'll enjoy skimming but not skipping the familiar. This book calls itself a "Training & Reference" and is well suited to both.

This book might look intimidatingly large, this one weighing in at 660 pages. However, due to the style, it's lighter than you think.

"with NetBeans"
Most Java books deal with Eclipse, which I find to be a complex mess out of the box. For the beginner, or anyone, I strongly recommend NetBeans and was appreciative of the choice. I later learned they offer an Eclipse version of the book as well, but we won't hold that against them.

"Get started right"
Most programming books throw the language concepts at you up front, the move on to examples of what has been explained. Here, the order of presentation seems slightly inverted, but interesting.

Section One gives the standard intro to Java that you might expect. Then, rather than getting into language specifics, we get into programming environment specifics: NetBeans. This kind of instruction is often sorely lacking in beginner's books that tend to expect you to figure out the basics of the tools on your own. Not so, here. We are invited to open existing projects, feel around the IDE, and run something.

Then, we're given our first program, told what the lines do, and we're off. We examine code with NetBeans, are then given more code, then more IDE, then more code. The entire first section proceeds like this, presenting the reader with just enough information about programming to play with the code presented. We move very quickly to successively more complex code and how to use NetBeans with it.

The whirlwind ride ends with a nice chapter on debugging. At this point, I'm more than a little concerned. We've covered a lot with little depth. Will the reader be able to program anything at given this? I begin to worry about this review.

"Essential skills as you need them"
Upon reading the first page of Section Two, I am greatly relieved. Here is all the information I'd expected earlier. The mundane nuts and bolts of programming. Primitive types, operators, control statements, arrays. Strings, which we just had to go with in Section One, are now more fully explained.

The subtitle of the section encapsulates the one of the core concepts of the book, "skill as you need them." In the book intro, the authors ask for feedback on their design choices. I'm curious as well. My feeling is that, for some folks, this particular book will resonate very strongly. I remain warily hopeful.

From this point on, the 10,000 feet flyover excitement is over. We get down to the actual details needed to write programs. I now have a new appreciation for Section One. The guts of a language are interesting if you have some idea of what programming is, but dull and confusing without context. The prior section gave us that context, enlivening this more traditional stuff. This is the section that will be the beginner's reference, with types and string methods.

"Object-oriented programming skills"
Section Three gives us OOP. The first chapter is "How to work with inheritance" and that's how we come to know classes. While the information is accurate and well presented, I do find this choice unfortunate. The logic of the chapter is to introduce Object as the Java base class and go from there.

My problem with this is that inheritance always seems overemphasized in OOP and the mindset can lead to some bad habits. Objects holds state and their most vital quality is encapsulation. While Encapsulation is noted when classes are first introduced in Section One, it is never heard from again in the rest of the book. One can only assume this wasn't seen as "essential." which is a bit of a disappointment.

The next chapter offers interfaces and does a good job with it. Interfaces versus abstract classes, which were introduced in the prior chapter, are discussed. I wish they'd made a better case for interfaces over abstract classes, but they at least spend more time and depth on them.

"More essential skills as you need them"
Section Four finds the kitchen sink, with collections, generics, lambdas, dates, times, exceptions, file I/O, and threads. Another strength of this book is making clear when certain features come into Java. Not just Java 8, which is well covered, like lambdas, but when generics, Scanner, and other toys show up.

"Real-world skills"
Section Five is the last and one of the shortest in the book. It covers MySQL, JDBC, and two chapters on "GUI with Swing."

I was surprised by the brevity of the GUI part. It should be noted that this book appears to follow a similar format to the larger Murach's Java Programming, which does devote more time to GUI and incidentally introduces databases after. So, this last section feels a lot like the checking off of the "all you need to know" ticky box. However, the information is good and my only real issue here is that these relatively anemic chapters could be longer.

Online Resources
Working through the code in the book is probably the best way for the beginner to learn. The first chapter and a zip of starter code and solutions is available from the site: https://www.murach.c...netbeans-detail

Final Thoughts
The most important criteria here, indeed perhaps the only one, is whether a book "specifically for beginning programmers" imparts "the core Java skills that you need to move on to web or Android programming."

There is an unusual level of self awareness in this text and its presentation. There is a feeling that editorial choices are consistently made with the students' needs in mind. The material is presented in an approachable and engaging way. If any book can teach someone to program, this one probably can.

Overall, I feel I can recommend this to the Java, or programming, newbie.

Picking Nits
What follows are my two biggest complaints, along with a saga to fix one. Students need read no further. However, in the interests of maybe addressing these issues in future editions:

The Concept of Emptiness
A core concept of most programming languages, Java being no exception, is NULL. Any Java programmer can recall some of their earliest errors being java.lang.NullPointerException. Yet, this is mentioned only once ( I donít think the database section counts for this) in relation to strings and initializing a "null string." This was rather striking for its lack.

Online Resources, to the pain
My first problem with the download was the register wall! I normally don't hand out my email and would have walked away, but for this review. ( I gave away my info for you, dear reader.) I don't consider anything that requires information from me, about me, to be "free" in a meaningful sense. So, not "FREE Downloads" as the site declares.

Upon paying the info fee, you are simply redirected. You are cookied at this point; registered. Note that you will be unregistered should you clear that cookie. While I cannot spare you registration, I can recommend you pay attention to the download url, which will tell you where to go to get the information again from the publisher without the song and dance. It will also allow you to find a couple other PDFs, the errors and TOC, not listed on the site.

The zip file is generally helpful, containing code from the book, exercise starts and exercise solutions. A readme would have been nice here.

The first couple projects open fine in NetBeans. Then you get to the ones that tell you they're broken and can't find source. You can fix this if you can navigate to the right directory, but you'll have to do it for every single project with this issue.

I have a quick fix for this, but first a little fun. Some sleuthing found the offending file in the private directory of each nbproject directory, in (I love that filename. ) Here's a quick look at one:
$ cat java_netbeans/ex_starts/ch10_ex1_ArrayTest/nbproject/private/ 

So, if nothing else, we now know that Joel Murach's username is Joel and that he uses Windows. Hi Joel.

The easiest solution by far is just to delete the entire private directory in the project. If you do NOT have Windows, the following shell command from the java_netbeans root will fix you right up:
find . -type d -name private -exec rm -r {} \;

While I appreciated having ex_starts projects, I wouldn't have minded if some multiple projects were combined into one. Indeed, some package naming would go a long way here. Also, if the start projects had a brief comment explaining the goal as stated in the book, it would have alleviated a lot of page to screen swapping.

Is This A Good Question/Topic? 3
  • +

Replies To: Book Review: Murach's Beginning Java with NetBeans

#2 modi123_1  Icon User is online

  • Suitor #2
  • member icon

Reputation: 10840
  • View blog
  • Posts: 42,465
  • Joined: 12-June 08

Posted 21 October 2015 - 11:27 AM


Then, rather than getting into language specifics, we get into programming environment specifics

One of the more awesome aspects of the book line.. kick the tools for a minute so you are not tossed in the deep end.
Was This Post Helpful? 0
  • +
  • -

Page 1 of 1