Working With VM Arguments as a Co-op Student

Stereotypically, interns are known to receive the short end of the stick. Whether it’s cleaning up scrappy (and usually unimportant) parts of a project, or doing boring brain-dead tasks that the full-time members are too busy to do, the work that we interns tend to receive is usually viewed as miscellaneous housework.

Two weeks into working as a VM intern at IBM on the Eclipse OpenJ9 team, I had that exact same mindset after receiving my second task. I was looking over the GitHub issue I had just received, and I read over the title: Options starting with -XX: should not be ignored. Great. This sounds exactly like the stereotypical work I described above: something miscellaneous that was handed off to me because the full-timers were too busy working on a much more important project. Admittedly, I’m still a second year on my second ever internship, but I did believe that my skills were good enough to not be treated like any regular intern. My last task involved me replacing duplicate macros, so in my head, I jumped the gun and thought, “Oh no, I guess this term has gone to waste.” Fortunately, throughout this internship I’ve been proven completely wrong, and I’ve dedicated this blog post to explain why.

For the first couple of months on the team, I was tasked to add various command line options to the VM (you can check out my work here), with the ultimate goal of creating a more intuitive CLI (command line interface). At first one would think that adding command line arguments might seem like an easy, boring task. However, that was not necessarily the case. For example, wrapping one’s head around all of the hundreds of data structures / macros that were being used in the code was definitely challenging, and OpenJ9’s codebase could be described more as a code ocean. Fortunately for me, the code is structured in a very, clean, understandable manner. Additionally, by going over the code when adding these new options, I’ve learned a ton of different programming techniques that I can use with my own code/projects. Whether it’s a fancy way to double-cast pointers, or using flags/bitwise logic to cleanly manage option flags, I can confidently say that I’ve added new weapons to my coding arsenal throughout the term.

While working with VM options might seem boring, I found the process of working with others and pushing new enhancements to production very exciting. Such a process required a lot of collaboration with other team members, as there were many steps I had to take before my changes were live (a lot more complicated than just pushing changes to master haha). This included getting code reviews, writing Java tests for the options, and running grinders (tests that are ran several times to account for the dynamic nature of Java) to ensure compatibility of the new option on all operating systems. Throughout this process, I learned various skills when it comes to working in a team. This includes technical skills like working with Git (e.g. forks, rebases, PR builds, etc.), as well as soft skills such as communication when discussing issues/comments in a pull request. The work done in a team versus work done alone is as different as night and day. Much more collaboration between team members is required, and different opinions from others must be accounted for. By talking with other team members and discussing the best way to implement a change, I’ve honed this critical team-working skill, which I will use for the rest of my career.

Finally, I would like to talk a bit more about the importance of adding/enhancing VM arguments, and how it affects OpenJ9 from a business standpoint. Ultimately, the goal of these enhancements was to match Hotspot’s (another JVM implementation) behaviour as close as possible, which adds a sense of familiarity when users switch over VMs. As a naive co-op student midway into February, I came to realize that the work I’ve been doing actually has a huge impact on OpenJ9’s client base and customers. On the other side of my work, I have actual, real-time users making use of the new options I created. This wasn’t some miscellaneous house work that needed to be done “just because”. Rather, the work I did created a more intuitive CLI for OpenJ9 customers, which from a business point of view, helps increase both the customer base and the customer satisfaction of our users.

To summarize this post, I definitely enjoyed my experience as a VM student in the OpenJ9 team. I’ve learned many new skills (both technical and soft skills), and I’ve honed my arsenal programming techniques. As well, quick shoutout to my mentor Tobi Ajila, who helped me with my work throughout the term (and somehow still wasn’t fed up with me even after I barraged him with millions of questions on a daily basis). It felt amazing having an actual impact on such a cool project, and I would definitely recommend any students who are looking for an internship to look into OpenJ9!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s