After using Java for about four years, I started wondering how well I really understood the language, so I started looking into Sun’s certification. Sun offers the following certifications:
- Sun Certified Programmer
- Sun Certified Developer
- Sun Certified Web Component Developer
- Sun Certified Business Component Developer
- Sun Certified Developer for Java Web Services
- Sun Certified Enterprise Architech
- Sun Certified Mobile Application Developer
The Programmer certification is the pre-requisite for all of the other certifications. It consists of a 61 question, two hour test taken at a Prometric testing center. You need at least a 52% to pass. At first I was surprised at such a low passing score, however it makes more sense given the complexity of the questions.
The Developer certification involves writing an actual application based on specifications from Sun. After completing the program, you take a test over your design choices. It seems the test is to make sure that you actually wrote the code yourself.
Since the Programmer certification was the only one I was eligible for, I started looking for a good study guide. Several years ago I worked through a book by McGraw-Hill when preparing for a CCNA exam. I liked the format so I was pleased when I found for the Java exam. I ordered it used from Amazon. After it arrived I noticed it was jointly written by Kathy Sierra. Kathy specialty is cognition and learning. She worked for Sun and helped develop the Java exams. She is also the creator of the Head First series of books published by O’Reilly and Java Ranch (a website dedicated to Java certification topics).
I’ve always been amazed at my wife’s ability sit down with a 500 page medical study guide and work through it only three or four days. Normally I work through study books over several weeks or months, but I decided to try Haley’s approach this time. It took me about 5 days to work through the Programmer part of the book (about 500 pages). Most of the book was familiar, but it cleared up a lot of small misunderstandings I had about what Java was doing behind the scenes.
The book does a great job of explaining why things work in a certian way instead of just giving you a list of things to memorize. This is easy to take for granted until you try to use a study guide that doesn’t do this.
Each section of the book ends with a series of questions that are similiar to questions on the actual exam. These study questions are very useful because they help test your understanding of nuances of the language that you might not catch from just reading the material.
As I worked through the book I wrote a bunch of small practice programs to test different concepts and make sure I understood how they worked. In retrospect, this was the most valuable part of my study. As I have time, I’ll post pieces of the sample code here along with explanations.
After going through the book, I tried to install the practice tests that came on the CD. I couldn’t get them to run, so I bought the ePractice online tests from Sun. For $75 you get 180 days of access to three practice tests. When you take a test it keeps your answers so you can come back and review them later. You can reset the test and take it again if you want. Each question has a button to see the answer and and an explanation.
I worked through the first and second test checking my answers as I went. After marking my first choice for an answer I would look at the explanation to see if I got it right. I always left my first choice marked so I could see my score at the end. When I took the third test I went through the entire thing and then went back over the answers.
The practice tests were good and seemed to cover the same material that was in the book. The one item that wasn’t covered in the book that showed up on the practice exam regarding setting a thread to run as a daemon. I discovered that I missed more than a few questions simply because I didn’t read them closely. For example, on multiple choice questions the exam will tell you how many answers you should choose. I missed several because I simply forgot to make sure I had selected the correct number of answers.
While passing the ePractice tests doesn’t guarantee that you’ll pass the actual exam, the level of difficulty is comparable to the actual exam.
I was a little disappointed that the ePractice exams only showed you a total score. on the actual exam your score is broken down into the following categories.
- Declarations and Access Control
- Flow control, Assertions, and Exception Handling
- Garbage Collection
- Language Fundamentals
- Operators and Assignments
- Overloading, Overriding, Runtime Type and Object Orientation
- Fundamental Classes in the java.lang Package
- The Collections Framework
Notice that it doesn’t cover any GUI programming. This is a change from the 1.2 version of the exam.
On the practice exams I got scores ranging from 65% to 80%. I probably would have done just fine on the exam at that point, but I wasn’t comfortable in risking the $150 to take the test. I found another book that people said was much more difficult than the actual exam and started working through it. A Programmer’s Guide to Java Certification seemed more difficult than the McGraw-Hill book, but it is very detailed. While the detail is good, the explanations aren’t as lucid as they could be. It would be helpful if the authors would spend more time explaining why you should expect a certian behaviour instead of just telling you what to expect. I worked through the book and then took the computerized practice test that came on the CD.
You can download the mock exam engine from here. It was fairly tough, but I ended up with a 70%. This exam engine is like the actual test. It doesn’t tell you the answer to any individual question, but it breaks your score down by section. The thing that makes this mock exam difficult is the way the questions test multiple things at one time. For example, it may appear that you are being tested on the construction of a for loop when the example code won’t compile at all because of a missing semicolon.
I scheduled the exam for the following day and passed with a 90% broken down as follows:
- Declarations and Access Control — 100%
- Flow control, Assertions, and Exception Handling — 100%
- Garbage Collection — 100%
- Language Fundamentals — 80%
- Operators and Assignments — 100%
- Overloading, Overriding, Runtime Type and Object Orientation — 83%
- Threads — 62%
- Fundamental Classes in the java.lang Package — 100%
- The Collections Framework — 100%
I’m not sure why I did so poorly on the Thread section, but overall I was very pleased with the score and I was able to complete the exam before Christmas. It took me two days to get out of intense study mode, but I was still able to have some time to relax before the holiday was over.