Newcomers’ Training Program

Recently, I was in charge of training two fresh-graduate newcomers to our department. My mission was to prepare a two weeks program to ease the integration process with their teams.

After a short brainstorming, I decided to break the training into the following seven topics:

1. Agile Practices: Their first assignment was getting acquainted with the Agile methodologies (mainly XP, our working process). I asked them to read a couple of chapters from two books, “The Art of Agile Development” and “Extreme Programming Explained.”
2. Dev Tools: Configuring some dev tools on their machines was the second step. This involved installing and configuring Java, IntelliJ, Maven, and Perforce. Some of those tools, such as Perforce and Maven, were relatively new, so they took time to learn more about them.
3. TDD: By now, they were ready to write some code! And what would be better than following TDD to do that? Most of our teams started adopting TDD; thus, coaching newcomers on TDD for simple dev problems is a must! For that purpose, I picked the following two problems:
   • Mars Rover: This might be an easy problem, but I find it well suited to practice TDD, especially for TDD newbies, as it has a lot of cases to be covered by tests.
   • Coffee Machine: The beauty of this problem, is that it simulates what happens in the life cycle of an agile project, such as:
     • Defining new requirements at the start of each iteration
     • Writing the minimum code to implement the required features
     • Continuous code refactoring
     • Write sufficient tests at each iteration
4. Design Pattern and Code Refactoring: The two problems above may not be complex and can be solved quickly, but the solution wasn’t the primary purpose rather, it was introducing new concepts and practices to them. To ensure this purpose was achieved, I performed multiple code review sessions during each iteration and suggested enhancement at each time. This process elongated the time for each iteration, but it was worth it. Some of the concepts I focused on were:
   • Test coverage
   • Builder pattern
   • Visitor pattern
   • Factory pattern
   • Bad and good code practices
   • Mocking
5. Maven: They used Maven to build the code they wrote previously, but it was only maven’s basic commands. At this phase of the training, I asked them to dig deeper into maven to have a better understanding of how it works, mainly focusing on the following:
   • Phases of the build lifecycle
   • Dependency management
   • Plugins
   • Local and remote repositories
6. SCM: Whether it is Git or Perforce, there are a couple of must-know operations for any developer to be part of a development team. As a practice on those operations, they simulated a real dev cycle scenario by:
   • Sharing a standard working directory on Perforce
   • Creating branches
   • Merging/Integrating changes
   • Resolving conflicts
7. Continuous Integration (CI)As fresh graduates, continuous integration was a new concept for them. Whereas for us, it is an essential process of our development cycle. It wasn’t possible to use an existing Jenkins instance to perform their testing; thus, they executed the below steps:
   • Download and configure Jenkins locally on their machines
   • Submit their code to Perforce
   • Add a new job that syncs, compile code, and execute the tests

I noticed the benefit of this training from the emails they sent me at the end of the program. They detailed what they learned, and most importantly, they were able to highlight the advantages of those practices and tools.

I hope you find this post helpful for your next newcomers’ training!