Last month I passed the Java SE 11 Developer 1Z0-819 exam. I'd be lying if I said it was easy. It's been well over a decade since I've coded without a compiler and an IDE telling me when I'm being an idiot. It was a necessary reminder that to master anything we must start with the very basics.
Exam Overview
The exam consists of 50 multiple choice questions in 90 minutes and a score of 68% is considered passing.
The topics covered include
- Working with java data types
- Controlling program flow with loops, switch, if/else
- Object Oriented Programming: Classes and lifecycle, nested classes, inheritance, encapsulation, polymorphism, abstract classes, interfaces, enums
- Exception handling
- Arrays and Collections
- Streams and Lambdas
- Java Platform module system
- Concurrency
- I/O API
- Security
- JDBC
- Localization
- Annotations
At first glance, these are all relatively straightforward and as a Java professional for most of my career, I did not find the initial overview daunting. However, once I started going over the exercises, I quickly realized that I haven't worked directly with the native java implementations but rather used Spring Boot and a suite of open source dependencies to accomplish most tasks. I'd relied heavily on Hybernate and Spring Data over native JDBC. I used Jackson over native serialization/deserialization. I used the Spring abstractions and annotations for async tasks over the native Java classes. I had a lot to learn.
One of the stumbling blocks for me was that my understanding of streams was incomplete. In my prior working experience, I had taken on the task of converting many loops in an existing code base to stream operations. However, I worked on a larger team and many of my teammates were unfamiliar with the new format. They had a hard time debugging the stream operations so quite a bit of my work ended up being reverted in favor of the loops that they felt comfortable using. If we had longer delivery timelines we may have been able to get everyone comfortable, but deliverables took priority over innovation during that time. With that work being put on the back burner, I didn't have the daily opportunity to work with streams and got quite rusty.
For serialization/deserialization, I've relied on the Jackson framework and Google's Gson framework and never really bothered with the native java implementation. Jackson's ObjectMapper class was a staple in everyday coding and it provided a straightforward approach. Getting back to the basics of Java serialization took a bit of learning.
How to Study
I would not have passed without a study guide and the book I recommend is OCP Oracle Certified Professional Java SE 11 Developer Complete Study Guide. The book is divided into two parts with the first covering the basics and the second covering the advanced topics. I read the first part once and the second part twice to memorize everything needed for the exam.
The second indispensable study tool is flashcards and mock exam questions. Just reading the material without practice will not yield the necessary understanding to apply the concepts. The book above comes with companion electronic flashcards and mock exams on a separate platform. They also offer a mobile app so you can study on the go. I found the Efficient Learning site that hosts the test bank and flashcards only worked in Chrome and is a bit glitchy but it got the job done. The good news here is that the test questions in the study guide were usually more difficult than any of the questions on the actual exam. The test platform also has many questions with multiple correct answers while the actual exam will tell you that there are 1, 2, or 3 correct answers that you must select for each question.
One of the study techniques I used to used was spaced repetition. It's been a decade since I finished school and I was out of practice memorizing. Spaced repetition is an evidence-based approach for learning, usually using flash cards. New and more difficult flashcards are reviewed more often while older/easier/already learned cards are reviewed less often. All cards are reviewed periodically to reinforce memorization. There are many ways to automate this process. One option is to create your own set of flashcards on the Anki platform which allows you to set your spaced repetition cadence and move cards from higher to lower priority as you master the concepts. For a training overview on Anki, I recommend this course on Skillshare by Ali Abdaal.
The reason spaced repetition is important is because of the Forgetting Curve which was demonstrated by Hermann Ebbinghuis in 1885. His experiment showed that there is an exponential loss in memory unless the information is reinforced. With spaced repetition, we reinforce information at set intervals to counteract our natural memory loss over time. It’s the use it or lose it concept.
For more information on this concept and other study techniques, check out Ali Abdaal's content here or Jade Bowler's book, The Only Study Guide You'll Ever Need
Takeaways
If you're passing all of the chapter quizzes and practice exams, then the real exam will be a breeze. Review topics that you struggle with multiple times and code the practice problems in your preferred environment. Practice, practice, practice and you'll pass.
And now for the personal rant... I don't think this exam is a good measure of whether you're a quality engineer. It is a test of whether you can code reasonably well without a compiler, which is certainly an indication of your level of understanding of a language, but nobody codes without an IDE and test harness in a professional setting. The exam tests how well you memorize, which again is not necessarily a useful criterion for a developer. Any developer who says they don't rely heavily on Google/StackOverflow is lying (or working within a very narrow technical scope where you can realistically retain everything you need to know). When I look for quality engineers to hire, I look for their problem-solving skills and communication skills over their ability to regurgitate all the required annotations for a specific implementation.
I won't be moving away from Spring or the many other dependencies I rely on in a professional setting to build out backend services but I do know more of the underlying java foundation that these tools are built upon which might prove handy in debugging more complex problems.
I do recommend this exam for new developers who might lack professional experience since it lays out the foundation of the language and demonstrates your proficiency to prospective employers.
