Introduction

If you are working as a software developer you have already faced with the situation that you are starting on a new project, where you don’t understand anything, but you should start to work on the tasks as soon as possible.

Of course it is not an easy situation, but it goes much faster if you are doing the ramp-up process in the correct way.

And if you can understand the project fast you will be encountered as a good professional.

I collected some suggestions based on my own experiences below. I hope they can help you.

Tips and Tricks

Understand the current and the expected functionality

Before going into technical details you have to understand two things: what is the program currently doing and what is its expected behavior once the current task/project is done.

You should start this process by reading the requirements or the user guideline if they exist. Then you should start the program and play with that. Try to figure out as much functionality as possible and make notes. Collect also questions in the meanwhile and ask them from your colleagues before going into technical details.

Reading the already existing test cases can also help a lot.

Never start the implementation of the new function until it is not 100% clear how it should work, what should be its outcome.

Get a technical overview

Once the functionality is clear you should get a technical overview. As part of this you should read the technical documentation and the software design if exists. You should focus on the following points: which technologies (language, framework etc.) are used for which purpose, what are the main components of the software and how are the components communicating to each other (which interfaces are used, what is the information flow etc.).

In this stage you should setup your development environment, checkout and compile the source code and run it on your own.

You can also draw some diagrams for yourself to get an overview.

Identify smaller parts of the code

Once the high level components are more or less clear you can go deeper for the ones which are relevant from your tasks. If you are analysing a piece of code (class, function, subcomponent etc.) always concentrate on the following questions: what are the inputs, what are the outputs, how does it produce the output based on the inputs (which algorithm is used etc.) and who is using the code.

Don’t get lost in the details

At the beginning you don’t need to understand every small detail. If you already have an overview and if you have an idea about which part of code needs to be modified, you should just jump into the water and start to implement the first part of your task. You will understand the details during work.

Ask in a structured way

The best if you can understand as much as possible based on the code and the documentation. But most of the cases it is not giving a totally clean overview on everything. In such cases you should ask your colleagues. But you should do it in a professional way:

• Collect what do you already understand and what is missing
• Collect your questions on a paper
• Tell briefly your current understanding to your colleague and ask if it is correct
• Ask your questions
• If something is still not clear try to ask by focusing on the still open points.
• After the discussion make notes and check everything again

In the beginning always ask your colleagues to review what you have done

Since there can be some misunderstanding in the beginning, it is good to ask your colleagues to review your changes in small pieces, even if it is not part of the company culture. Be always open on critics and suggestions.

Summary

Every start is challenging, but if you are doing your ramp up in a well-structured way you can make it much easier.