How GO-JEK Engineering Bootcamp helped me become a better version of myself

I began coding when I joined my college. Since Android development was trending at that time I decided to give it a try and have been coding ever since. After finishing my B-Tech I was lucky enough to join GO-JEK as a product engineer.

As soon as I joined GO-JEK, I along with 15+ other graduates from India and Indonesia joined the GO-JEK Engineering Bootcamp.

The team :D

1. Core Engineering

The core engineering module was the most diverse module of the entire bootcamp. Since this module was not limited to any specific kind of technology, it had a lot of things to offer. This module was not restricted to programming and taught us a lot of other things like team and time management. We also got to know great insights about GO-JEK on an organization level.

Here is everything we learned in this module — —

Discipline — In the core engineering bootcamp there was a list of etiquette that was supposed to be followed whenever you write any code. In case you missed any one of them, the code used to get rm -rf and you had to start again from the very beginning. Although it might look really easy but trust me it is not.

NON NEGOTIABLE ETIQUETTES @GO-JEK-BOOTCAMP* Indentation and spacing between code constructs (classes/methods/specs) must be consistent
* Use only spaces (no tabs) for indentation
* Newlines at end of file
* Follow accepted naming conventions for your language/framework
* Follow accepted naming file and Directory structure for your language/framework
* Use namespaces
* No comments/Unused Code must ever be checked in
* Runtime environment should be consistent with IDE environment - i.e there should be no difference in running a build or a spec from your IDE and from the command line
* Use .gitignore
* Ensure there is a that includes
* Problem Description
* Dev environment setup
* Build instructions
* Run instructions
* BDD (this should show in clear pattern in the commit log - one spec, one code change per commit)

After getting rm -rf many times, we realized how difficult it is to follow a simple list of non-negotiable etiquette. Over the next 3 months of the bootcamp, we as a group tried to reduce the number of rm -rf that we get by reviewing each others code.

Test-driven development — Writing test is really important at GO-JEK and TDD is rigorously followed here. In the entire core engineering bootcamp, we followed TDD. A pattern of red (failing spec), green (passing spec) and commit was followed. We would also refactor our code and commit again if required.

Pair programming — Another practice that is present at GO-JEK that we followed in the entire bootcamp was pair programming. Working together in pairs showed us how each individual has their unique way of tackling a problem. We learned about agreeing fast and moving forward. We used to have a different pair every single day.

OOPS — Every graduate “knew” OOPS. But this module changed our perspective about it. What we had was all theoretical/incomplete knowledge that we didn’t know how to apply. We learned a lot of key concepts like Tell don’t ask, why getters and setters are a hack and when to use them, polymorphism and SOLID principles.

It’s always about the team — At the beginning of this module, one thing was made clear to us. This bootcamp is not a competition. It’s not about who is better than whom, it’s about the team. It’s about how we as a team perform in the bootcamp. This made us realize that there is a bigger picture than all of us, it’s our team. We need to work as a team so that everyone is at the same level when the bootcamp ends.

There is nobody else — Don’t leave broken windows thinking that somebody else will fix them. The ideology at GO-JEK is that there is nobody else so don’t wait for someone else to fix it, do it yourself.

2. Talks with Sidu Ponnappa — We used to have some great talks with Sidu during breaks and sometimes during the sessions about life, money, happiness, introvertism, why we should read books, which books to read, great pioneers in our industry and a lot more. These talks were both inspiring and informative.

3. One of the focus in this module was to learn the shortcuts of the IDEs we use. Primarily we used Ruby Mine and IntelliJ. We were discouraged to use the mouse during code showcases or when writing code. Learning shortcuts made us more productive and fast.

4. We learned a lot of principles that we had never heard about. It’s a long list but some of them are DRY, Pareto’s principle, Tell don’t ask, Rule of 3 and SOLID.

2. DevOps

The DevOps module of the bootcamp was focused on automation. Here we got to know what DevOps really is, learned the importance of automation and how we can automate various monotonous tasks for better efficiency and reliability. In this module, we create a Rails API and then deployed it on a Linux virtual machine. Here is everything we learned in this module —

Googling — One of the most challenging and unique things about this module was the way it was taught. Rather than spoon feeding us with the answers, we were asked to google things. This way we got to know a lot of things that we could have missed otherwise.

Vagrant — We got to know what is vagrant and what pain points does it solve. We went into the importance of making code platform independent and how vagrant can help us achieve that. We wrote scripts that would download code from Gitlab and install all the dependencies on a Linux virtual machine (using Linux image in vagrant)

Docker — After vagrant, we went onto docker. We got to know some key differences between vagrant and docker. Later we repeated the exercises that we did with vagrant using Docker.

Learn Linux the hard way — Since there are no IDEs in deployment it is really important to know terminal commands. We completed all the 30 chapters of Learn Linux the hard way. We got to know some really cool things like filesystems: mounting, mount, /etc/fstab and job schedulers: cron, at.

CI — Continuous integration is an integral part of development. Here we learned how to create a YAML file and what all can be done with it. We learned about stage and jobs. We learned how we can create the artifact which can be deployed to our production servers.

1. HTTP RFC — We got to know a lot of things about HTTP through the RFC document. You can find the document here.

2. Microservices — We learned about microservices, their advantages and how they are used in GO-JEK.

3. Chef and cookbooks — We used chef a configuration management tool along with cookbooks that contain recipes used by chef.

4. Minikube, Kubernetes, and Haproxy — We also got a gist of what is minikube and kubernetes and how to achieve load balancing using Haproxy.

3. Android

The Android module of the bootcamp aimed to get us acquainted with some of the concepts and libraries that are used in the GO-JEK android application. Since all of us were familiar with Java transition to Kotlin for the bootcamp was not that difficult. Here is everything we learned in this module —

Layouts — We learned about Linear, relative and frame layout. When to use which of them, their pros and cons. We also learned about how deep layout hierarchy can slow down your application.

Activity and Fragment — We learned a lot about activities and fragments. We got to know about their life cycles, how they are different from each other and when to use them. We also discussed how to start one activity from another, how to manage your fragment stack and adding a fragment inside an activity.

Data Storage — Here we learned how to use SharedPreferences. We discussed how you can read and write data to shared preferences, what are the benefits of using shared preferences and it’s structure.

Multi-threading — We got to know why we can’t make a network request on the main thread of an application. How can we tackle this situation? We first learned about the async task and how to use them. Later on, we tackled the same problem using Okhttp which is also used in the GO-JEK application. We also discussed handler and loopers in android.

List — One of the most used features in android would be a showing a list. Every app nowadays shows some sort of list. To implement a list in android we learned about RecyclerView. We discussed how it is better than the ListView and how it actually recycles its items. We also learned how to create an adapter and viewHolder for a recycler view.

Architecture — Testing your application is really important. But when you write all your code in your activity it becomes less readable and testable. This taught us the importance of separating your code. We learned about architectures like MVC and MVP, how are they different from one another. We first created our application with MVC and later refactored it to MVP.

1. Importance of strings, colors, and dimens.xml — We got insights about how strings.xml helps with multiple languages, colors.xml helps with keeping all the colors at a single place and dimens.xml helps when targeting multiple types of devices like mobile and tablets.

2. Mockito and Espresso — We got to know a little bit about testing also. We had a brief introduction about Mockito (used for unit testing) and Espresso (use for instrumentation testing).

3. Kotlin — We discussed various ways to handle nulls in kotlin, what are apply and let functions, SAM, lamdas, higher-order functions, and data class.

4. Context in android — One of the most talked about topic in android for beginners at least is context. We discussed what is a context and different types of context.

5. Namespaces in android — We got to know about different namespaces in android, key differences among them and when to use which of them.

6. Using debugger with AndroidStudio — We learned how to attach a debugger to our application, how to add breakpoints and use them to debug our apps.

7. Gradle and its task — We got to know about gradle and how dependencies are managed in gradle. We discussed some of the predefined tasks in gradle and how we can use them to install and assemble our apk using the terminal

This is what we created in a week-long Android bootcamp

4. Security

How many times do you think about security while writing code?. This is what the security module of the bootcamp was all about. In this module, we were shown demos of different vulnerabilities that are usually present in web and mobile application and how we can use them to gain unauthorized access. The aim was to make us realize the importance of security. In this module, we create a Java API that would be tested for various vulnerabilities like SQL Injection and IDOR. Here is everything we learned in this module —

Case Studies — To show how important security is there was an ample amount of discussion on security breaches at GO-JEK. Not only GO-JEK, but we also got to know about the history of security breaches at Facebook and Twitter. We realized how negligence to security in code can be a nightmare for the company.

Malware — We went through different types of malware like Ransomware, Worms, Trojans. We discussed in detail their implications through some real-life examples.

Vulnerabilities— We discussed various vulnerabilities that can be found in codebases. We went over how we can use SQL injection in web and mobile application to get hold of data in the databases. We got to know about various SQL injection tools like SQLMap. We also discussed some common attacks like IDOR (Insecure Direct Object Reference) and XSS.

Tackling Vulnerabilities — We also learned how we can protect ourselves from such attacks. Use of prepared statements to tackle SQL injection is one such example. We also got to know how captcha can be used to prevent brute force intrusion attacks, how rate limiting can be used and how using proper timeouts for rate limiting can help us.

1. Authentication vs Authorization — We discussed what is authentication and authorization and how are they different from one another.

2. GPG Keys — We got to know about GPG keys, their importance and how we can use them to sign our commits.

3. Manifest in Android — Their our various tags in the android manifest can pose a security threat to your application. Using exported=”true” for your services or broadcast receiver is one such example.

4. Rooting—We saw how an application can be manipulated on a rooted device. It is really important that you take appropriate security measures when your app is installed on a rooted device.

5. Never trust anyone with your important information—Always keep your personal information to yourself. Never share sensitive information. No matter who asks for it always ask for the reason behind it.

5. Data Science

The data science module of the bootcamp gave us a small introduction to the data science world. It was a really short module just 3 days long but made us familiar with some data science concepts and terminologies.

Basics — We were introduced to some basic concepts that are a data science engineer should know. We touched concepts like Classification, Clustering, Regression, Supervised and Unsupervised Learnings, Linear Regression, and Gradient Descent. We also got to know various kinds of error metrics used which included Mean Square Error(MSE), Root Mean Square Error(RMSE) and Mean Error(ME).

Pandas and Matplotlib — We got familiar with the usage of pandas for data exploration, and use of matplotlib to visualize the inferences drawn from the data. We learned about various kinds of plots like histogram, box plots, correlation heat maps.

Kaggle— The last day we tried Kaggle’s Advanced House Price Prediction Challenge. After writing the solution we submitted them for evaluation and got our respective ranks. We gained familiarity with Kaggle and also learned how to use these concepts to solve real world problems.

1. Data Science at GO-JEK — We had some good discussion about how data science works and what are the challenges that it is trying to solve.

2. Performance metrics — We had a brief discussion about metrics like Accuracy, Precision, Recall, Sensitivity and Specificity which come handy while evaluating model performances.

6. iOS

The iOS module of the bootcamp aimed to get us acquainted with some of the concepts that are used in the GO-JEK application. Since most of us were not familiar with Swift, the coaches spent an ample amount of time teaching it.
Here is everything we learned in this module —

Swift — The first two days of this bootcamp module were entirely focused on getting familiar with swift. We went through the syntax of the language covering different data structures and learning concepts like extensions and protocols. We also got some great insights into the language.

Layouts — We learned about creating layouts for the app using constraints, using drag and drop for linking UI elements with the actual swift code and adding actions to UI element. We also got to know about storyboards and xibs, their pros and cons and why xibs are preferred over storyboards.

Multi-threading — We learned about the importance of multithreading when doing a resource-intensive task on the main thread of the application. We saw how we can handle task such as network calls asynchronously using inbuilt APIs.

List — We learned how to display a list using UITableView, how to recycle cells that are part of such a list for memory efficiency and how we can create our custom cells by using UITableViewCell.

Apart from these modules, there were a few exercises that we did every day for 3 months in the bootcamp

1. Speaking Drills

Throughout the bootcamp, we were introduced to a variety of terms that can be used to describe an argument like Anecdotal Evidence, Strawman, Circular Reasoning. These terms were used throughout the speaking drills sessions to check the logical consistency of the argument.
The speaking drills used to have 3 levels

Level 0 — In this level, the speaker had to speak for 30 seconds about anything. The aim of this level was to become confident and get rid of any sort of stage fear that you might have.

Level 1 — In this level, the speaker had to speak for 1 minute on a pre-decided topic. The aim of this level was to convince others about the argument that you make. Once the speaker is done with his/her 1 minute, the argument that was made is logically questioned by others thereby making it a success or failure.

Level 2 —This is similar to level 1, the only difference being that the topic on which you have to make your argument is given on the spot and you get only 30 seconds to prepare your content.

2. Type Racers

The aim of type racers was pretty straightforward. All of us were supposed to have a typing speed of greater than 50 wpm by the end of the bootcamp. There was only one rule — No peeking at the keyboard while typing. We used to have 3 type racers every day and the best of them was used to keep track of our typing speed.

This bootcamp has been an amazing journey. I don’t think many companies invest this amount of time and energy for their new joinees. We could’nt have asked for a better onboarding than this !

Sr. Software Engineer IndMoney | ex GO-JEK | GSoC 2018 @openMF | Mobile | Backend | mohak1712 everywhere