WavebreakmediaMicro - Fotolia
Succeed with the test-first Java certification prep approach
Java certification exam prep is an important step for anyone interested in the test. Consider a test-first approach that might help you more effectively study for the exam.
The conventional way that the IT industry awards technical certification is an experience in educational torture. The process for a Java certification exam, for example, is: You take an exam, you pass and you're awarded the certification. Unless you already have a firm, almost encyclopedic grasp of the knowledge required to pass the exam, you'll probably ingest as much information as possible over a short period of time to prepare for the exam. This is classic cramming -- stuff it in, and spew it out.
One way to prepare for the exam is to take practice tests. Another way involves Java certification prep classes offered by authorized companies. The exact exam questions, however, remain a mystery until test time.
Cramming as part of certification prep is nothing new. That's been the case since well before professional IT certification came along. But there's another method for Java certification prep, and those who practice formal test-driven development (TDD) have used it for years. It's called the test-first approach.
New approach to Java certification prep
For this approach, you first make software by writing the test that verifies the code behavior you intend to create. Obviously, this test will fail. Next, you implement new code that will change the failing result to a passing one. In the test-first approach, test failure is an expected and welcomed event, which is the exact opposite of the IT certification process.
If you were to apply TDD to a certification examination, for example, a test taker would go into the test process with the option to take it at least twice. You would expect that the first instance will result in failure because the questions are unknown. On subsequent attempts, the test taker would know the questions and have the required information to pass the test.
Is this cheating? To me, cheating is about deception. If a person wants to have a firm understanding of the expectations at hand and then engages in behavior to satisfy those expectations, it's anything but deceitful.
Another criticism of a test-first approach for Java certification is memorization. A test taker could continually take the same test, with the same question set, memorize the answers and never fully grasp the underlying concepts and knowledge of the material. Multiple-choice and short-answer questions lend themselves to rote learning. And they're not a particularly good instrument to measure the higher-order cognition required to master concepts and generate analysis.
Typically, essay questions are the better way to measure conceptual and analytical knowledge. But since those are difficult to score, we end up with multiple-choice and short-answer questions. The problem therein lies not with the test-first approach, but with the test design.
The test-first approach is a more relaxed way to prepare for certification testing. It removes some stress without compromising the quality of the results. However, there is some downside when a test subject expects to fail and builds toward eventual success -- one of which is the cost. Currently, Oracle's Java 8 certification exam costs $250. Not everyone can afford to take a hit like that three or four times.
After all, isn't the purpose of professional certification to attest that the certificate recipient has the necessary knowledge and qualifications to perform their duties to the standards of the certifying authority and not that they can answer 75% of 60 questions asked within an 80-minute testing period? I hope it's the former.
I prefer the test-first approach to IT exams and Java certification prep. It's good that the test taker will correctly answer all the questions over time rather than the first try. It's a better way than the conventional exam method that leaves only one opportunity to take the exam and requires only a percentage passing grade instead of a perfect score. Software testers learned a long time ago that it's not the 75% of the code that's been covered that poses the greatest risk; it's the 25% that hasn't.
